1 // 2 // Copyright (C) 2018 Google, Inc. 3 // 4 // All rights reserved. 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions 8 // are met: 9 // 10 // Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // 13 // Redistributions in binary form must reproduce the above 14 // copyright notice, this list of conditions and the following 15 // disclaimer in the documentation and/or other materials provided 16 // with the distribution. 17 // 18 // Neither the name of 3Dlabs Inc. Ltd. nor the names of its 19 // contributors may be used to endorse or promote products derived 20 // from this software without specific prior written permission. 21 // 22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 // POSSIBILITY OF SUCH DAMAGE. 34 35 // 36 // Post-processing for SPIR-V IR, in internal form, not standard binary form. 37 // 38 39 #include <cassert> 40 #include <cstdlib> 41 42 #include <unordered_set> 43 #include <algorithm> 44 45 #include "SpvBuilder.h" 46 47 #include "spirv.hpp" 48 #include "GlslangToSpv.h" 49 #include "SpvBuilder.h" 50 namespace spv { 51 #include "GLSL.std.450.h" 52 #include "GLSL.ext.KHR.h" 53 #include "GLSL.ext.EXT.h" 54 #ifdef AMD_EXTENSIONS 55 #include "GLSL.ext.AMD.h" 56 #endif 57 #ifdef NV_EXTENSIONS 58 #include "GLSL.ext.NV.h" 59 #endif 60 } 61 62 namespace spv { 63 64 // Hook to visit each operand type and result type of an instruction. 65 // Will be called multiple times for one instruction, once for each typed 66 // operand and the result. 67 void Builder::postProcessType(const Instruction& inst, Id typeId) 68 { 69 // Characterize the type being questioned 70 Id basicTypeOp = getMostBasicTypeClass(typeId); 71 int width = 0; 72 if (basicTypeOp == OpTypeFloat || basicTypeOp == OpTypeInt) 73 width = getScalarTypeWidth(typeId); 74 75 // Do opcode-specific checks 76 switch (inst.getOpCode()) { 77 case OpLoad: 78 case OpStore: 79 if (basicTypeOp == OpTypeStruct) { 80 if (containsType(typeId, OpTypeInt, 8)) 81 addCapability(CapabilityInt8); 82 if (containsType(typeId, OpTypeInt, 16)) 83 addCapability(CapabilityInt16); 84 if (containsType(typeId, OpTypeFloat, 16)) 85 addCapability(CapabilityFloat16); 86 } else { 87 StorageClass storageClass = getStorageClass(inst.getIdOperand(0)); 88 if (width == 8) { 89 switch (storageClass) { 90 case StorageClassPhysicalStorageBufferEXT: 91 case StorageClassUniform: 92 case StorageClassStorageBuffer: 93 case StorageClassPushConstant: 94 break; 95 default: 96 addCapability(CapabilityInt8); 97 break; 98 } 99 } else if (width == 16) { 100 switch (storageClass) { 101 case StorageClassPhysicalStorageBufferEXT: 102 case StorageClassUniform: 103 case StorageClassStorageBuffer: 104 case StorageClassPushConstant: 105 case StorageClassInput: 106 case StorageClassOutput: 107 break; 108 default: 109 if (basicTypeOp == OpTypeInt) 110 addCapability(CapabilityInt16); 111 if (basicTypeOp == OpTypeFloat) 112 addCapability(CapabilityFloat16); 113 break; 114 } 115 } 116 } 117 break; 118 case OpAccessChain: 119 case OpPtrAccessChain: 120 case OpCopyObject: 121 case OpFConvert: 122 case OpSConvert: 123 case OpUConvert: 124 break; 125 case OpExtInst: 126 #if AMD_EXTENSIONS 127 switch (inst.getImmediateOperand(1)) { 128 case GLSLstd450Frexp: 129 case GLSLstd450FrexpStruct: 130 if (getSpvVersion() < glslang::EShTargetSpv_1_3 && containsType(typeId, OpTypeInt, 16)) 131 addExtension(spv::E_SPV_AMD_gpu_shader_int16); 132 break; 133 case GLSLstd450InterpolateAtCentroid: 134 case GLSLstd450InterpolateAtSample: 135 case GLSLstd450InterpolateAtOffset: 136 if (getSpvVersion() < glslang::EShTargetSpv_1_3 && containsType(typeId, OpTypeFloat, 16)) 137 addExtension(spv::E_SPV_AMD_gpu_shader_half_float); 138 break; 139 default: 140 break; 141 } 142 #endif 143 break; 144 default: 145 if (basicTypeOp == OpTypeFloat && width == 16) 146 addCapability(CapabilityFloat16); 147 if (basicTypeOp == OpTypeInt && width == 16) 148 addCapability(CapabilityInt16); 149 if (basicTypeOp == OpTypeInt && width == 8) 150 addCapability(CapabilityInt8); 151 break; 152 } 153 } 154 155 // Called for each instruction that resides in a block. 156 void Builder::postProcess(Instruction& inst) 157 { 158 // Add capabilities based simply on the opcode. 159 switch (inst.getOpCode()) { 160 case OpExtInst: 161 switch (inst.getImmediateOperand(1)) { 162 case GLSLstd450InterpolateAtCentroid: 163 case GLSLstd450InterpolateAtSample: 164 case GLSLstd450InterpolateAtOffset: 165 addCapability(CapabilityInterpolationFunction); 166 break; 167 default: 168 break; 169 } 170 break; 171 case OpDPdxFine: 172 case OpDPdyFine: 173 case OpFwidthFine: 174 case OpDPdxCoarse: 175 case OpDPdyCoarse: 176 case OpFwidthCoarse: 177 addCapability(CapabilityDerivativeControl); 178 break; 179 180 case OpImageQueryLod: 181 case OpImageQuerySize: 182 case OpImageQuerySizeLod: 183 case OpImageQuerySamples: 184 case OpImageQueryLevels: 185 addCapability(CapabilityImageQuery); 186 break; 187 188 #ifdef NV_EXTENSIONS 189 case OpGroupNonUniformPartitionNV: 190 addExtension(E_SPV_NV_shader_subgroup_partitioned); 191 addCapability(CapabilityGroupNonUniformPartitionedNV); 192 break; 193 #endif 194 195 case OpLoad: 196 case OpStore: 197 { 198 // For any load/store to a PhysicalStorageBufferEXT, walk the accesschain 199 // index list to compute the misalignment. The pre-existing alignment value 200 // (set via Builder::AccessChain::alignment) only accounts for the base of 201 // the reference type and any scalar component selection in the accesschain, 202 // and this function computes the rest from the SPIR-V Offset decorations. 203 Instruction *accessChain = module.getInstruction(inst.getIdOperand(0)); 204 if (accessChain->getOpCode() == OpAccessChain) { 205 Instruction *base = module.getInstruction(accessChain->getIdOperand(0)); 206 // Get the type of the base of the access chain. It must be a pointer type. 207 Id typeId = base->getTypeId(); 208 Instruction *type = module.getInstruction(typeId); 209 assert(type->getOpCode() == OpTypePointer); 210 if (type->getImmediateOperand(0) != StorageClassPhysicalStorageBufferEXT) { 211 break; 212 } 213 // Get the pointee type. 214 typeId = type->getIdOperand(1); 215 type = module.getInstruction(typeId); 216 // Walk the index list for the access chain. For each index, find any 217 // misalignment that can apply when accessing the member/element via 218 // Offset/ArrayStride/MatrixStride decorations, and bitwise OR them all 219 // together. 220 int alignment = 0; 221 for (int i = 1; i < accessChain->getNumOperands(); ++i) { 222 Instruction *idx = module.getInstruction(accessChain->getIdOperand(i)); 223 if (type->getOpCode() == OpTypeStruct) { 224 assert(idx->getOpCode() == OpConstant); 225 int c = idx->getImmediateOperand(0); 226 227 const auto function = [&](const std::unique_ptr<Instruction>& decoration) { 228 if (decoration.get()->getOpCode() == OpMemberDecorate && 229 decoration.get()->getIdOperand(0) == typeId && 230 decoration.get()->getImmediateOperand(1) == c && 231 (decoration.get()->getImmediateOperand(2) == DecorationOffset || 232 decoration.get()->getImmediateOperand(2) == DecorationMatrixStride)) { 233 alignment |= decoration.get()->getImmediateOperand(3); 234 } 235 }; 236 std::for_each(decorations.begin(), decorations.end(), function); 237 // get the next member type 238 typeId = type->getIdOperand(c); 239 type = module.getInstruction(typeId); 240 } else if (type->getOpCode() == OpTypeArray || 241 type->getOpCode() == OpTypeRuntimeArray) { 242 const auto function = [&](const std::unique_ptr<Instruction>& decoration) { 243 if (decoration.get()->getOpCode() == OpDecorate && 244 decoration.get()->getIdOperand(0) == typeId && 245 decoration.get()->getImmediateOperand(1) == DecorationArrayStride) { 246 alignment |= decoration.get()->getImmediateOperand(2); 247 } 248 }; 249 std::for_each(decorations.begin(), decorations.end(), function); 250 // Get the element type 251 typeId = type->getIdOperand(0); 252 type = module.getInstruction(typeId); 253 } else { 254 // Once we get to any non-aggregate type, we're done. 255 break; 256 } 257 } 258 assert(inst.getNumOperands() >= 3); 259 unsigned int memoryAccess = inst.getImmediateOperand((inst.getOpCode() == OpStore) ? 2 : 1); 260 assert(memoryAccess & MemoryAccessAlignedMask); 261 // Compute the index of the alignment operand. 262 int alignmentIdx = 2; 263 if (memoryAccess & MemoryAccessVolatileMask) 264 alignmentIdx++; 265 if (inst.getOpCode() == OpStore) 266 alignmentIdx++; 267 // Merge new and old (mis)alignment 268 alignment |= inst.getImmediateOperand(alignmentIdx); 269 // Pick the LSB 270 alignment = alignment & ~(alignment & (alignment-1)); 271 // update the Aligned operand 272 inst.setImmediateOperand(alignmentIdx, alignment); 273 } 274 break; 275 } 276 277 default: 278 break; 279 } 280 281 // Checks based on type 282 if (inst.getTypeId() != NoType) 283 postProcessType(inst, inst.getTypeId()); 284 for (int op = 0; op < inst.getNumOperands(); ++op) { 285 if (inst.isIdOperand(op)) { 286 // In blocks, these are always result ids, but we are relying on 287 // getTypeId() to return NoType for things like OpLabel. 288 if (getTypeId(inst.getIdOperand(op)) != NoType) 289 postProcessType(inst, getTypeId(inst.getIdOperand(op))); 290 } 291 } 292 } 293 294 // Called for each instruction in a reachable block. 295 void Builder::postProcessReachable(const Instruction&) 296 { 297 // did have code here, but questionable to do so without deleting the instructions 298 } 299 300 // comment in header 301 void Builder::postProcess() 302 { 303 std::unordered_set<const Block*> reachableBlocks; 304 std::unordered_set<Id> unreachableDefinitions; 305 // Collect IDs defined in unreachable blocks. For each function, label the 306 // reachable blocks first. Then for each unreachable block, collect the 307 // result IDs of the instructions in it. 308 for (auto fi = module.getFunctions().cbegin(); fi != module.getFunctions().cend(); fi++) { 309 Function* f = *fi; 310 Block* entry = f->getEntryBlock(); 311 inReadableOrder(entry, [&reachableBlocks](const Block* b) { reachableBlocks.insert(b); }); 312 for (auto bi = f->getBlocks().cbegin(); bi != f->getBlocks().cend(); bi++) { 313 Block* b = *bi; 314 if (reachableBlocks.count(b) == 0) { 315 for (auto ii = b->getInstructions().cbegin(); ii != b->getInstructions().cend(); ii++) 316 unreachableDefinitions.insert(ii->get()->getResultId()); 317 } 318 } 319 } 320 321 // Remove unneeded decorations, for unreachable instructions 322 decorations.erase(std::remove_if(decorations.begin(), decorations.end(), 323 [&unreachableDefinitions](std::unique_ptr<Instruction>& I) -> bool { 324 Id decoration_id = I.get()->getIdOperand(0); 325 return unreachableDefinitions.count(decoration_id) != 0; 326 }), 327 decorations.end()); 328 329 // Add per-instruction capabilities, extensions, etc., 330 331 // process all reachable instructions... 332 for (auto bi = reachableBlocks.cbegin(); bi != reachableBlocks.cend(); ++bi) { 333 const Block* block = *bi; 334 const auto function = [this](const std::unique_ptr<Instruction>& inst) { postProcessReachable(*inst.get()); }; 335 std::for_each(block->getInstructions().begin(), block->getInstructions().end(), function); 336 } 337 338 // process all block-contained instructions 339 for (auto fi = module.getFunctions().cbegin(); fi != module.getFunctions().cend(); fi++) { 340 Function* f = *fi; 341 for (auto bi = f->getBlocks().cbegin(); bi != f->getBlocks().cend(); bi++) { 342 Block* b = *bi; 343 for (auto ii = b->getInstructions().cbegin(); ii != b->getInstructions().cend(); ii++) 344 postProcess(*ii->get()); 345 346 // For all local variables that contain pointers to PhysicalStorageBufferEXT, check whether 347 // there is an existing restrict/aliased decoration. If we don't find one, add Aliased as the 348 // default. 349 for (auto vi = b->getLocalVariables().cbegin(); vi != b->getLocalVariables().cend(); vi++) { 350 const Instruction& inst = *vi->get(); 351 Id resultId = inst.getResultId(); 352 if (containsPhysicalStorageBufferOrArray(getDerefTypeId(resultId))) { 353 bool foundDecoration = false; 354 const auto function = [&](const std::unique_ptr<Instruction>& decoration) { 355 if (decoration.get()->getIdOperand(0) == resultId && 356 decoration.get()->getOpCode() == OpDecorate && 357 (decoration.get()->getImmediateOperand(1) == spv::DecorationAliasedPointerEXT || 358 decoration.get()->getImmediateOperand(1) == spv::DecorationRestrictPointerEXT)) { 359 foundDecoration = true; 360 } 361 }; 362 std::for_each(decorations.begin(), decorations.end(), function); 363 if (!foundDecoration) { 364 addDecoration(resultId, spv::DecorationAliasedPointerEXT); 365 } 366 } 367 } 368 } 369 } 370 371 // Look for any 8/16 bit type in physical storage buffer class, and set the 372 // appropriate capability. This happens in createSpvVariable for other storage 373 // classes, but there isn't always a variable for physical storage buffer. 374 for (int t = 0; t < (int)groupedTypes[OpTypePointer].size(); ++t) { 375 Instruction* type = groupedTypes[OpTypePointer][t]; 376 if (type->getImmediateOperand(0) == (unsigned)StorageClassPhysicalStorageBufferEXT) { 377 if (containsType(type->getIdOperand(1), OpTypeInt, 8)) { 378 addExtension(spv::E_SPV_KHR_8bit_storage); 379 addCapability(spv::CapabilityStorageBuffer8BitAccess); 380 } 381 if (containsType(type->getIdOperand(1), OpTypeInt, 16) || 382 containsType(type->getIdOperand(1), OpTypeFloat, 16)) { 383 addExtension(spv::E_SPV_KHR_16bit_storage); 384 addCapability(spv::CapabilityStorageBuffer16BitAccess); 385 } 386 } 387 } 388 } 389 390 }; // end spv namespace 391
