validate_image.cpp | Explore in Territory

// 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 <string>

#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() { … }

// Used by GetImageTypeInfo. See OpTypeImage spec for more information.
struct ImageTypeInfo { … };

// 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) { … }

bool IsImplicitLod(spv::Op opcode) { … }

bool IsExplicitLod(spv::Op opcode) { … }

bool IsValidLodOperand(const ValidationState_t& _, spv::Op opcode) { … }

bool IsValidGatherLodBiasAMD(const ValidationState_t& _, spv::Op opcode) { … }

// Returns true if the opcode is a Image instruction which applies
// homogenous projection to the coordinates.
bool IsProj(spv::Op opcode) { … }

// 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) { … }

// 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) { … }

// 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) { … }

// Validate OpImage*Proj* instructions
spv_result_t ValidateImageProj(ValidationState_t& _, const Instruction* inst,
                               const ImageTypeInfo& info) { … }

// Validate OpImage*Read and OpImage*Write instructions
spv_result_t ValidateImageReadWrite(ValidationState_t& _,
                                    const Instruction* inst,
                                    const ImageTypeInfo& info) { … }

// Returns true if opcode is *ImageSparse*, false otherwise.
bool IsSparse(spv::Op opcode) { … }

// 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) { … }

// 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) { … }

spv_result_t ValidateTypeImage(ValidationState_t& _, const Instruction* inst) { … }

spv_result_t ValidateTypeSampledImage(ValidationState_t& _,
                                      const Instruction* inst) { … }

bool IsAllowedSampledImageOperand(spv::Op opcode, ValidationState_t& _) { … }

spv_result_t ValidateSampledImage(ValidationState_t& _,
                                  const Instruction* inst) { … }

spv_result_t ValidateImageTexelPointer(ValidationState_t& _,
                                       const Instruction* inst) { … }

spv_result_t ValidateImageLod(ValidationState_t& _, const Instruction* inst) { … }

// Validates anything OpImage*Dref* instruction
spv_result_t ValidateImageDref(ValidationState_t& _, const Instruction* inst,
                               const ImageTypeInfo& info) { … }

spv_result_t ValidateImageDrefLod(ValidationState_t& _,
                                  const Instruction* inst) { … }

spv_result_t ValidateImageFetch(ValidationState_t& _, const Instruction* inst) { … }

spv_result_t ValidateImageGather(ValidationState_t& _,
                                 const Instruction* inst) { … }

spv_result_t ValidateImageRead(ValidationState_t& _, const Instruction* inst) { … }

spv_result_t ValidateImageWrite(ValidationState_t& _, const Instruction* inst) { … }

spv_result_t ValidateImage(ValidationState_t& _, const Instruction* inst) { … }

spv_result_t ValidateImageQuerySizeLod(ValidationState_t& _,
                                       const Instruction* inst) { … }

spv_result_t ValidateImageQuerySize(ValidationState_t& _,
                                    const Instruction* inst) { … }

spv_result_t ValidateImageQueryFormatOrOrder(ValidationState_t& _,
                                             const Instruction* inst) { … }

spv_result_t ValidateImageQueryLod(ValidationState_t& _,
                                   const Instruction* inst) { … }

spv_result_t ValidateImageSparseLod(ValidationState_t& _,
                                    const Instruction* inst) { … }

spv_result_t ValidateImageQueryLevelsOrSamples(ValidationState_t& _,
                                               const Instruction* inst) { … }

spv_result_t ValidateImageSparseTexelsResident(ValidationState_t& _,
                                               const Instruction* inst) { … }

spv_result_t ValidateImageProcessingQCOMDecoration(ValidationState_t& _, int id,
                                                   spv::Decoration decor) { … }

spv_result_t ValidateImageProcessing2QCOMWindowDecoration(ValidationState_t& _,
                                                          int id) { … }

spv_result_t ValidateImageProcessingQCOM(ValidationState_t& _,
                                         const Instruction* inst) { … }

}  // namespace

// Validates correctness of image instructions.
spv_result_t ImagePass(ValidationState_t& _, const Instruction* inst) { … }

bool IsImageInstruction(const spv::Op opcode) { … }

spv_result_t ValidateQCOMImageProcessingTextureUsages(ValidationState_t& _,
                                                      const Instruction* inst) { … }

}  // namespace val
}  // namespace spvtools
chromium/third_party/spirv-tools/src/source/val/validate_image.cpp
