| // Copyright (c) 2019 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT 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 <functional> |
| #include <initializer_list> |
| #include <utility> |
| |
| #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<Instruction*> access_chains; |
| std::vector<Instruction*> 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<uint32_t>(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<uint32_t> words = spvtools::utils::MakeVector(glsl); |
| auto import_inst = MakeUnique<Instruction>( |
| context(), spv::Op::OpExtInstImport, 0, module_status_.glsl_insts_id, |
| std::initializer_list<Operand>{ |
| 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<uint32_t> 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<uint32_t> 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<Instruction>( |
| context(), spv::Op::OpCapability, 0, 0, |
| std::initializer_list<Operand>{ |
| {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<uint32_t>(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<uint32_t>(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<Instruction>(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 |
