| // | |
| // Copyright (C) 2018 Google, Inc. | |
| // | |
| // All rights reserved. | |
| // | |
| // 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 3Dlabs Inc. Ltd. 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 HOLDERS 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. | |
| // | |
| // Post-processing for SPIR-V IR, in internal form, not standard binary form. | |
| // | |
| #include <cassert> | |
| #include <cstdlib> | |
| #include <unordered_map> | |
| #include <unordered_set> | |
| #include <algorithm> | |
| #include "SpvBuilder.h" | |
| #include "spirv.hpp" | |
| #include "GlslangToSpv.h" | |
| #include "SpvBuilder.h" | |
| namespace spv { | |
| #include "GLSL.std.450.h" | |
| #include "GLSL.ext.KHR.h" | |
| #include "GLSL.ext.EXT.h" | |
| #include "GLSL.ext.AMD.h" | |
| #include "GLSL.ext.NV.h" | |
| } | |
| namespace spv { | |
| #ifndef GLSLANG_WEB | |
| // Hook to visit each operand type and result type of an instruction. | |
| // Will be called multiple times for one instruction, once for each typed | |
| // operand and the result. | |
| void Builder::postProcessType(const Instruction& inst, Id typeId) | |
| { | |
| // Characterize the type being questioned | |
| Id basicTypeOp = getMostBasicTypeClass(typeId); | |
| int width = 0; | |
| if (basicTypeOp == OpTypeFloat || basicTypeOp == OpTypeInt) | |
| width = getScalarTypeWidth(typeId); | |
| // Do opcode-specific checks | |
| switch (inst.getOpCode()) { | |
| case OpLoad: | |
| case OpStore: | |
| if (basicTypeOp == OpTypeStruct) { | |
| if (containsType(typeId, OpTypeInt, 8)) | |
| addCapability(CapabilityInt8); | |
| if (containsType(typeId, OpTypeInt, 16)) | |
| addCapability(CapabilityInt16); | |
| if (containsType(typeId, OpTypeFloat, 16)) | |
| addCapability(CapabilityFloat16); | |
| } else { | |
| StorageClass storageClass = getStorageClass(inst.getIdOperand(0)); | |
| if (width == 8) { | |
| switch (storageClass) { | |
| case StorageClassPhysicalStorageBufferEXT: | |
| case StorageClassUniform: | |
| case StorageClassStorageBuffer: | |
| case StorageClassPushConstant: | |
| break; | |
| default: | |
| addCapability(CapabilityInt8); | |
| break; | |
| } | |
| } else if (width == 16) { | |
| switch (storageClass) { | |
| case StorageClassPhysicalStorageBufferEXT: | |
| case StorageClassUniform: | |
| case StorageClassStorageBuffer: | |
| case StorageClassPushConstant: | |
| case StorageClassInput: | |
| case StorageClassOutput: | |
| break; | |
| default: | |
| if (basicTypeOp == OpTypeInt) | |
| addCapability(CapabilityInt16); | |
| if (basicTypeOp == OpTypeFloat) | |
| addCapability(CapabilityFloat16); | |
| break; | |
| } | |
| } | |
| } | |
| break; | |
| case OpAccessChain: | |
| case OpPtrAccessChain: | |
| case OpCopyObject: | |
| break; | |
| case OpFConvert: | |
| case OpSConvert: | |
| case OpUConvert: | |
| // Look for any 8/16-bit storage capabilities. If there are none, assume that | |
| // the convert instruction requires the Float16/Int8/16 capability. | |
| if (containsType(typeId, OpTypeFloat, 16) || containsType(typeId, OpTypeInt, 16)) { | |
| bool foundStorage = false; | |
| for (auto it = capabilities.begin(); it != capabilities.end(); ++it) { | |
| spv::Capability cap = *it; | |
| if (cap == spv::CapabilityStorageInputOutput16 || | |
| cap == spv::CapabilityStoragePushConstant16 || | |
| cap == spv::CapabilityStorageUniformBufferBlock16 || | |
| cap == spv::CapabilityStorageUniform16) { | |
| foundStorage = true; | |
| break; | |
| } | |
| } | |
| if (!foundStorage) { | |
| if (containsType(typeId, OpTypeFloat, 16)) | |
| addCapability(CapabilityFloat16); | |
| if (containsType(typeId, OpTypeInt, 16)) | |
| addCapability(CapabilityInt16); | |
| } | |
| } | |
| if (containsType(typeId, OpTypeInt, 8)) { | |
| bool foundStorage = false; | |
| for (auto it = capabilities.begin(); it != capabilities.end(); ++it) { | |
| spv::Capability cap = *it; | |
| if (cap == spv::CapabilityStoragePushConstant8 || | |
| cap == spv::CapabilityUniformAndStorageBuffer8BitAccess || | |
| cap == spv::CapabilityStorageBuffer8BitAccess) { | |
| foundStorage = true; | |
| break; | |
| } | |
| } | |
| if (!foundStorage) { | |
| addCapability(CapabilityInt8); | |
| } | |
| } | |
| break; | |
| case OpExtInst: | |
| switch (inst.getImmediateOperand(1)) { | |
| case GLSLstd450Frexp: | |
| case GLSLstd450FrexpStruct: | |
| if (getSpvVersion() < glslang::EShTargetSpv_1_3 && containsType(typeId, OpTypeInt, 16)) | |
| addExtension(spv::E_SPV_AMD_gpu_shader_int16); | |
| break; | |
| case GLSLstd450InterpolateAtCentroid: | |
| case GLSLstd450InterpolateAtSample: | |
| case GLSLstd450InterpolateAtOffset: | |
| if (getSpvVersion() < glslang::EShTargetSpv_1_3 && containsType(typeId, OpTypeFloat, 16)) | |
| addExtension(spv::E_SPV_AMD_gpu_shader_half_float); | |
| break; | |
| default: | |
| break; | |
| } | |
| break; | |
| default: | |
| if (basicTypeOp == OpTypeFloat && width == 16) | |
| addCapability(CapabilityFloat16); | |
| if (basicTypeOp == OpTypeInt && width == 16) | |
| addCapability(CapabilityInt16); | |
| if (basicTypeOp == OpTypeInt && width == 8) | |
| addCapability(CapabilityInt8); | |
| break; | |
| } | |
| } | |
| // Called for each instruction that resides in a block. | |
| void Builder::postProcess(Instruction& inst) | |
| { | |
| // Add capabilities based simply on the opcode. | |
| switch (inst.getOpCode()) { | |
| case OpExtInst: | |
| switch (inst.getImmediateOperand(1)) { | |
| case GLSLstd450InterpolateAtCentroid: | |
| case GLSLstd450InterpolateAtSample: | |
| case GLSLstd450InterpolateAtOffset: | |
| addCapability(CapabilityInterpolationFunction); | |
| break; | |
| default: | |
| break; | |
| } | |
| break; | |
| case OpDPdxFine: | |
| case OpDPdyFine: | |
| case OpFwidthFine: | |
| case OpDPdxCoarse: | |
| case OpDPdyCoarse: | |
| case OpFwidthCoarse: | |
| addCapability(CapabilityDerivativeControl); | |
| break; | |
| case OpImageQueryLod: | |
| case OpImageQuerySize: | |
| case OpImageQuerySizeLod: | |
| case OpImageQuerySamples: | |
| case OpImageQueryLevels: | |
| addCapability(CapabilityImageQuery); | |
| break; | |
| case OpGroupNonUniformPartitionNV: | |
| addExtension(E_SPV_NV_shader_subgroup_partitioned); | |
| addCapability(CapabilityGroupNonUniformPartitionedNV); | |
| break; | |
| case OpLoad: | |
| case OpStore: | |
| { | |
| // For any load/store to a PhysicalStorageBufferEXT, walk the accesschain | |
| // index list to compute the misalignment. The pre-existing alignment value | |
| // (set via Builder::AccessChain::alignment) only accounts for the base of | |
| // the reference type and any scalar component selection in the accesschain, | |
| // and this function computes the rest from the SPIR-V Offset decorations. | |
| Instruction *accessChain = module.getInstruction(inst.getIdOperand(0)); | |
| if (accessChain->getOpCode() == OpAccessChain) { | |
| Instruction *base = module.getInstruction(accessChain->getIdOperand(0)); | |
| // Get the type of the base of the access chain. It must be a pointer type. | |
| Id typeId = base->getTypeId(); | |
| Instruction *type = module.getInstruction(typeId); | |
| assert(type->getOpCode() == OpTypePointer); | |
| if (type->getImmediateOperand(0) != StorageClassPhysicalStorageBufferEXT) { | |
| break; | |
| } | |
| // Get the pointee type. | |
| typeId = type->getIdOperand(1); | |
| type = module.getInstruction(typeId); | |
| // Walk the index list for the access chain. For each index, find any | |
| // misalignment that can apply when accessing the member/element via | |
| // Offset/ArrayStride/MatrixStride decorations, and bitwise OR them all | |
| // together. | |
| int alignment = 0; | |
| for (int i = 1; i < accessChain->getNumOperands(); ++i) { | |
| Instruction *idx = module.getInstruction(accessChain->getIdOperand(i)); | |
| if (type->getOpCode() == OpTypeStruct) { | |
| assert(idx->getOpCode() == OpConstant); | |
| unsigned int c = idx->getImmediateOperand(0); | |
| const auto function = [&](const std::unique_ptr<Instruction>& decoration) { | |
| if (decoration.get()->getOpCode() == OpMemberDecorate && | |
| decoration.get()->getIdOperand(0) == typeId && | |
| decoration.get()->getImmediateOperand(1) == c && | |
| (decoration.get()->getImmediateOperand(2) == DecorationOffset || | |
| decoration.get()->getImmediateOperand(2) == DecorationMatrixStride)) { | |
| alignment |= decoration.get()->getImmediateOperand(3); | |
| } | |
| }; | |
| std::for_each(decorations.begin(), decorations.end(), function); | |
| // get the next member type | |
| typeId = type->getIdOperand(c); | |
| type = module.getInstruction(typeId); | |
| } else if (type->getOpCode() == OpTypeArray || | |
| type->getOpCode() == OpTypeRuntimeArray) { | |
| const auto function = [&](const std::unique_ptr<Instruction>& decoration) { | |
| if (decoration.get()->getOpCode() == OpDecorate && | |
| decoration.get()->getIdOperand(0) == typeId && | |
| decoration.get()->getImmediateOperand(1) == DecorationArrayStride) { | |
| alignment |= decoration.get()->getImmediateOperand(2); | |
| } | |
| }; | |
| std::for_each(decorations.begin(), decorations.end(), function); | |
| // Get the element type | |
| typeId = type->getIdOperand(0); | |
| type = module.getInstruction(typeId); | |
| } else { | |
| // Once we get to any non-aggregate type, we're done. | |
| break; | |
| } | |
| } | |
| assert(inst.getNumOperands() >= 3); | |
| unsigned int memoryAccess = inst.getImmediateOperand((inst.getOpCode() == OpStore) ? 2 : 1); | |
| assert(memoryAccess & MemoryAccessAlignedMask); | |
| static_cast<void>(memoryAccess); | |
| // Compute the index of the alignment operand. | |
| int alignmentIdx = 2; | |
| if (inst.getOpCode() == OpStore) | |
| alignmentIdx++; | |
| // Merge new and old (mis)alignment | |
| alignment |= inst.getImmediateOperand(alignmentIdx); | |
| // Pick the LSB | |
| alignment = alignment & ~(alignment & (alignment-1)); | |
| // update the Aligned operand | |
| inst.setImmediateOperand(alignmentIdx, alignment); | |
| } | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| // Checks based on type | |
| if (inst.getTypeId() != NoType) | |
| postProcessType(inst, inst.getTypeId()); | |
| for (int op = 0; op < inst.getNumOperands(); ++op) { | |
| if (inst.isIdOperand(op)) { | |
| // In blocks, these are always result ids, but we are relying on | |
| // getTypeId() to return NoType for things like OpLabel. | |
| if (getTypeId(inst.getIdOperand(op)) != NoType) | |
| postProcessType(inst, getTypeId(inst.getIdOperand(op))); | |
| } | |
| } | |
| } | |
| #endif | |
| // comment in header | |
| void Builder::postProcessCFG() | |
| { | |
| // reachableBlocks is the set of blockss reached via control flow, or which are | |
| // unreachable continue targert or unreachable merge. | |
| std::unordered_set<const Block*> reachableBlocks; | |
| std::unordered_map<Block*, Block*> headerForUnreachableContinue; | |
| std::unordered_set<Block*> unreachableMerges; | |
| std::unordered_set<Id> unreachableDefinitions; | |
| // Collect IDs defined in unreachable blocks. For each function, label the | |
| // reachable blocks first. Then for each unreachable block, collect the | |
| // result IDs of the instructions in it. | |
| for (auto fi = module.getFunctions().cbegin(); fi != module.getFunctions().cend(); fi++) { | |
| Function* f = *fi; | |
| Block* entry = f->getEntryBlock(); | |
| inReadableOrder(entry, | |
| [&reachableBlocks, &unreachableMerges, &headerForUnreachableContinue] | |
| (Block* b, ReachReason why, Block* header) { | |
| reachableBlocks.insert(b); | |
| if (why == ReachDeadContinue) headerForUnreachableContinue[b] = header; | |
| if (why == ReachDeadMerge) unreachableMerges.insert(b); | |
| }); | |
| for (auto bi = f->getBlocks().cbegin(); bi != f->getBlocks().cend(); bi++) { | |
| Block* b = *bi; | |
| if (unreachableMerges.count(b) != 0 || headerForUnreachableContinue.count(b) != 0) { | |
| auto ii = b->getInstructions().cbegin(); | |
| ++ii; // Keep potential decorations on the label. | |
| for (; ii != b->getInstructions().cend(); ++ii) | |
| unreachableDefinitions.insert(ii->get()->getResultId()); | |
| } else if (reachableBlocks.count(b) == 0) { | |
| // The normal case for unreachable code. All definitions are considered dead. | |
| for (auto ii = b->getInstructions().cbegin(); ii != b->getInstructions().cend(); ++ii) | |
| unreachableDefinitions.insert(ii->get()->getResultId()); | |
| } | |
| } | |
| } | |
| // Modify unreachable merge blocks and unreachable continue targets. | |
| // Delete their contents. | |
| for (auto mergeIter = unreachableMerges.begin(); mergeIter != unreachableMerges.end(); ++mergeIter) { | |
| (*mergeIter)->rewriteAsCanonicalUnreachableMerge(); | |
| } | |
| for (auto continueIter = headerForUnreachableContinue.begin(); | |
| continueIter != headerForUnreachableContinue.end(); | |
| ++continueIter) { | |
| Block* continue_target = continueIter->first; | |
| Block* header = continueIter->second; | |
| continue_target->rewriteAsCanonicalUnreachableContinue(header); | |
| } | |
| // Remove unneeded decorations, for unreachable instructions | |
| decorations.erase(std::remove_if(decorations.begin(), decorations.end(), | |
| [&unreachableDefinitions](std::unique_ptr<Instruction>& I) -> bool { | |
| Id decoration_id = I.get()->getIdOperand(0); | |
| return unreachableDefinitions.count(decoration_id) != 0; | |
| }), | |
| decorations.end()); | |
| } | |
| #ifndef GLSLANG_WEB | |
| // comment in header | |
| void Builder::postProcessFeatures() { | |
| // Add per-instruction capabilities, extensions, etc., | |
| // Look for any 8/16 bit type in physical storage buffer class, and set the | |
| // appropriate capability. This happens in createSpvVariable for other storage | |
| // classes, but there isn't always a variable for physical storage buffer. | |
| for (int t = 0; t < (int)groupedTypes[OpTypePointer].size(); ++t) { | |
| Instruction* type = groupedTypes[OpTypePointer][t]; | |
| if (type->getImmediateOperand(0) == (unsigned)StorageClassPhysicalStorageBufferEXT) { | |
| if (containsType(type->getIdOperand(1), OpTypeInt, 8)) { | |
| addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5); | |
| addCapability(spv::CapabilityStorageBuffer8BitAccess); | |
| } | |
| if (containsType(type->getIdOperand(1), OpTypeInt, 16) || | |
| containsType(type->getIdOperand(1), OpTypeFloat, 16)) { | |
| addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3); | |
| addCapability(spv::CapabilityStorageBuffer16BitAccess); | |
| } | |
| } | |
| } | |
| // process all block-contained instructions | |
| for (auto fi = module.getFunctions().cbegin(); fi != module.getFunctions().cend(); fi++) { | |
| Function* f = *fi; | |
| for (auto bi = f->getBlocks().cbegin(); bi != f->getBlocks().cend(); bi++) { | |
| Block* b = *bi; | |
| for (auto ii = b->getInstructions().cbegin(); ii != b->getInstructions().cend(); ii++) | |
| postProcess(*ii->get()); | |
| // For all local variables that contain pointers to PhysicalStorageBufferEXT, check whether | |
| // there is an existing restrict/aliased decoration. If we don't find one, add Aliased as the | |
| // default. | |
| for (auto vi = b->getLocalVariables().cbegin(); vi != b->getLocalVariables().cend(); vi++) { | |
| const Instruction& inst = *vi->get(); | |
| Id resultId = inst.getResultId(); | |
| if (containsPhysicalStorageBufferOrArray(getDerefTypeId(resultId))) { | |
| bool foundDecoration = false; | |
| const auto function = [&](const std::unique_ptr<Instruction>& decoration) { | |
| if (decoration.get()->getIdOperand(0) == resultId && | |
| decoration.get()->getOpCode() == OpDecorate && | |
| (decoration.get()->getImmediateOperand(1) == spv::DecorationAliasedPointerEXT || | |
| decoration.get()->getImmediateOperand(1) == spv::DecorationRestrictPointerEXT)) { | |
| foundDecoration = true; | |
| } | |
| }; | |
| std::for_each(decorations.begin(), decorations.end(), function); | |
| if (!foundDecoration) { | |
| addDecoration(resultId, spv::DecorationAliasedPointerEXT); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| #endif | |
| // comment in header | |
| void Builder::postProcess() { | |
| postProcessCFG(); | |
| #ifndef GLSLANG_WEB | |
| postProcessFeatures(); | |
| #endif | |
| } | |
| }; // end spv namespace |