1 // Copyright (c) 2023 Google Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #ifndef SOURCE_OPT_TRIM_CAPABILITIES_PASS_H_ 16 #define SOURCE_OPT_TRIM_CAPABILITIES_PASS_H_ 17 18 #include <algorithm> 19 #include <array> 20 #include <functional> 21 #include <optional> 22 #include <unordered_map> 23 #include <unordered_set> 24 25 #include "source/enum_set.h" 26 #include "source/extensions.h" 27 #include "source/opt/ir_context.h" 28 #include "source/opt/module.h" 29 #include "source/opt/pass.h" 30 #include "source/spirv_target_env.h" 31 32 namespace spvtools { 33 namespace opt { 34 35 // This is required for NDK build. The unordered_set/unordered_map 36 // implementation don't work with class enums. 37 struct ClassEnumHash { operatorClassEnumHash38 std::size_t operator()(spv::Capability value) const { 39 using StoringType = typename std::underlying_type_t<spv::Capability>; 40 return std::hash<StoringType>{}(static_cast<StoringType>(value)); 41 } 42 operatorClassEnumHash43 std::size_t operator()(spv::Op value) const { 44 using StoringType = typename std::underlying_type_t<spv::Op>; 45 return std::hash<StoringType>{}(static_cast<StoringType>(value)); 46 } 47 }; 48 49 // An opcode handler is a function which, given an instruction, returns either 50 // the required capability, or nothing. 51 // Each handler checks one case for a capability requirement. 52 // 53 // Example: 54 // - `OpTypeImage` can have operand `A` operand which requires capability 1 55 // - `OpTypeImage` can also have operand `B` which requires capability 2. 56 // -> We have 2 handlers: `Handler_OpTypeImage_1` and 57 // `Handler_OpTypeImage_2`. 58 using OpcodeHandler = 59 std::optional<spv::Capability> (*)(const Instruction* instruction); 60 61 // This pass tried to remove superfluous capabilities declared in the module. 62 // - If all the capabilities listed by an extension are removed, the extension 63 // is also trimmed. 64 // - If the module countains any capability listed in `kForbiddenCapabilities`, 65 // the module is left untouched. 66 // - No capabilities listed in `kUntouchableCapabilities` are trimmed, even when 67 // not used. 68 // - Only capabilitied listed in `kSupportedCapabilities` are supported. 69 // - If the module contains unsupported capabilities, results might be 70 // incorrect. 71 class TrimCapabilitiesPass : public Pass { 72 private: 73 // All the capabilities supported by this optimization pass. If your module 74 // contains unsupported instruction, the pass could yield bad results. 75 static constexpr std::array kSupportedCapabilities{ 76 // clang-format off 77 spv::Capability::ComputeDerivativeGroupLinearNV, 78 spv::Capability::ComputeDerivativeGroupQuadsNV, 79 spv::Capability::Float16, 80 spv::Capability::Float64, 81 spv::Capability::FragmentShaderPixelInterlockEXT, 82 spv::Capability::FragmentShaderSampleInterlockEXT, 83 spv::Capability::FragmentShaderShadingRateInterlockEXT, 84 spv::Capability::Groups, 85 spv::Capability::ImageMSArray, 86 spv::Capability::Int16, 87 spv::Capability::Int64, 88 spv::Capability::Linkage, 89 spv::Capability::MinLod, 90 spv::Capability::PhysicalStorageBufferAddresses, 91 spv::Capability::RayQueryKHR, 92 spv::Capability::RayTracingKHR, 93 spv::Capability::RayTraversalPrimitiveCullingKHR, 94 spv::Capability::Shader, 95 spv::Capability::ShaderClockKHR, 96 spv::Capability::StorageImageReadWithoutFormat, 97 spv::Capability::StorageInputOutput16, 98 spv::Capability::StoragePushConstant16, 99 spv::Capability::StorageUniform16, 100 spv::Capability::StorageUniformBufferBlock16, 101 spv::Capability::VulkanMemoryModelDeviceScope, 102 spv::Capability::GroupNonUniformPartitionedNV 103 // clang-format on 104 }; 105 106 // Those capabilities disable all transformation of the module. 107 static constexpr std::array kForbiddenCapabilities{ 108 spv::Capability::Linkage, 109 }; 110 111 // Those capabilities are never removed from a module because we cannot 112 // guess from the SPIR-V only if they are required or not. 113 static constexpr std::array kUntouchableCapabilities{ 114 spv::Capability::Shader, 115 }; 116 117 public: 118 TrimCapabilitiesPass(); 119 TrimCapabilitiesPass(const TrimCapabilitiesPass&) = delete; 120 TrimCapabilitiesPass(TrimCapabilitiesPass&&) = delete; 121 122 private: 123 // Inserts every capability listed by `descriptor` this pass supports into 124 // `output`. Expects a Descriptor like `spv_opcode_desc_t` or 125 // `spv_operand_desc_t`. 126 template <class Descriptor> addSupportedCapabilitiesToSet(const Descriptor * const descriptor,CapabilitySet * output)127 inline void addSupportedCapabilitiesToSet(const Descriptor* const descriptor, 128 CapabilitySet* output) const { 129 const uint32_t capabilityCount = descriptor->numCapabilities; 130 for (uint32_t i = 0; i < capabilityCount; ++i) { 131 const auto capability = descriptor->capabilities[i]; 132 if (supportedCapabilities_.contains(capability)) { 133 output->insert(capability); 134 } 135 } 136 } 137 138 // Inserts every extension listed by `descriptor` required by the module into 139 // `output`. Expects a Descriptor like `spv_opcode_desc_t` or 140 // `spv_operand_desc_t`. 141 template <class Descriptor> addSupportedExtensionsToSet(const Descriptor * const descriptor,ExtensionSet * output)142 inline void addSupportedExtensionsToSet(const Descriptor* const descriptor, 143 ExtensionSet* output) const { 144 if (descriptor->minVersion <= 145 spvVersionForTargetEnv(context()->GetTargetEnv())) { 146 return; 147 } 148 output->insert(descriptor->extensions, 149 descriptor->extensions + descriptor->numExtensions); 150 } 151 152 void addInstructionRequirementsForOpcode(spv::Op opcode, 153 CapabilitySet* capabilities, 154 ExtensionSet* extensions) const; 155 void addInstructionRequirementsForOperand(const Operand& operand, 156 CapabilitySet* capabilities, 157 ExtensionSet* extensions) const; 158 159 // Given an `instruction`, determines the capabilities it requires, and output 160 // them in `capabilities`. The returned capabilities form a subset of 161 // kSupportedCapabilities. 162 void addInstructionRequirements(Instruction* instruction, 163 CapabilitySet* capabilities, 164 ExtensionSet* extensions) const; 165 166 // Given an operand `type` and `value`, adds the extensions it would require 167 // to `extensions`. 168 void AddExtensionsForOperand(const spv_operand_type_t type, 169 const uint32_t value, 170 ExtensionSet* extensions) const; 171 172 // Returns the list of required capabilities and extensions for the module. 173 // The returned capabilities form a subset of kSupportedCapabilities. 174 std::pair<CapabilitySet, ExtensionSet> 175 DetermineRequiredCapabilitiesAndExtensions() const; 176 177 // Trims capabilities not listed in `required_capabilities` if possible. 178 // Returns whether or not the module was modified. 179 Pass::Status TrimUnrequiredCapabilities( 180 const CapabilitySet& required_capabilities) const; 181 182 // Trims extensions not listed in `required_extensions` if supported by this 183 // pass. An extensions is considered supported as soon as one capability this 184 // pass support requires it. 185 Pass::Status TrimUnrequiredExtensions( 186 const ExtensionSet& required_extensions) const; 187 188 // Returns if the analyzed module contains any forbidden capability. 189 bool HasForbiddenCapabilities() const; 190 191 public: name()192 const char* name() const override { return "trim-capabilities"; } 193 Status Process() override; 194 195 private: 196 const CapabilitySet supportedCapabilities_; 197 const CapabilitySet forbiddenCapabilities_; 198 const CapabilitySet untouchableCapabilities_; 199 const std::unordered_multimap<spv::Op, OpcodeHandler, ClassEnumHash> 200 opcodeHandlers_; 201 }; 202 203 } // namespace opt 204 } // namespace spvtools 205 #endif // SOURCE_OPT_TRIM_CAPABILITIES_H_ 206