| // Copyright (c) 2020 André Perez Maselco |
| // |
| // 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. |
| |
| #include "source/fuzz/fuzzer_pass_add_image_sample_unused_components.h" |
| |
| #include "source/fuzz/fuzzer_util.h" |
| #include "source/fuzz/instruction_descriptor.h" |
| #include "source/fuzz/transformation_add_image_sample_unused_components.h" |
| #include "source/fuzz/transformation_composite_construct.h" |
| |
| namespace spvtools { |
| namespace fuzz { |
| |
| FuzzerPassAddImageSampleUnusedComponents:: |
| FuzzerPassAddImageSampleUnusedComponents( |
| opt::IRContext* ir_context, |
| TransformationContext* transformation_context, |
| FuzzerContext* fuzzer_context, |
| protobufs::TransformationSequence* transformations, |
| bool ignore_inapplicable_transformations) |
| : FuzzerPass(ir_context, transformation_context, fuzzer_context, |
| transformations, ignore_inapplicable_transformations) {} |
| |
| void FuzzerPassAddImageSampleUnusedComponents::Apply() { |
| // SPIR-V module to help understand the transformation. |
| // |
| // OpCapability Shader |
| // %1 = OpExtInstImport "GLSL.std.450" |
| // OpMemoryModel Logical GLSL450 |
| // OpEntryPoint Fragment %15 "main" %12 %14 |
| // OpExecutionMode %15 OriginUpperLeft |
| // |
| // ; Decorations |
| // OpDecorate %12 Location 0 ; Input color variable location |
| // OpDecorate %13 DescriptorSet 0 ; Image coordinate variable |
| // descriptor set OpDecorate %13 Binding 0 ; Image coordinate |
| // variable binding OpDecorate %14 Location 0 ; Fragment color |
| // variable location |
| // |
| // ; Types |
| // %2 = OpTypeVoid |
| // %3 = OpTypeFunction %2 |
| // %4 = OpTypeFloat 32 |
| // %5 = OpTypeVector %4 2 |
| // %6 = OpTypeVector %4 4 |
| // %7 = OpTypeImage %4 2D 0 0 0 1 Rgba32f |
| // %8 = OpTypeSampledImage %7 |
| // %9 = OpTypePointer Input %5 |
| // %10 = OpTypePointer UniformConstant %8 |
| // %11 = OpTypePointer Output %6 |
| // |
| // ; Variables |
| // %12 = OpVariable %9 Input ; Input image coordinate variable |
| // %13 = OpVariable %10 UniformConstant ; Image variable |
| // %14 = OpVariable %11 Output ; Fragment color variable |
| // |
| // ; main function |
| // %15 = OpFunction %2 None %3 |
| // %16 = OpLabel |
| // %17 = OpLoad %5 %12 |
| // %18 = OpLoad %8 %13 |
| // %19 = OpImageSampleImplicitLod %6 %18 %17 |
| // OpStore %14 %19 |
| // OpReturn |
| // OpFunctionEnd |
| |
| GetIRContext()->module()->ForEachInst([this](opt::Instruction* instruction) { |
| // |instruction| %19 = OpImageSampleImplicitLod %6 %18 %17 |
| if (!spvOpcodeIsImageSample(instruction->opcode())) { |
| return; |
| } |
| |
| if (!GetFuzzerContext()->ChoosePercentage( |
| GetFuzzerContext() |
| ->GetChanceOfAddingImageSampleUnusedComponents())) { |
| return; |
| } |
| |
| // Gets image sample coordinate information. |
| // |coordinate_instruction| %17 = OpLoad %5 %12 |
| uint32_t coordinate_id = instruction->GetSingleWordInOperand(1); |
| auto coordinate_instruction = |
| GetIRContext()->get_def_use_mgr()->GetDef(coordinate_id); |
| auto coordinate_type = GetIRContext()->get_type_mgr()->GetType( |
| coordinate_instruction->type_id()); |
| |
| // If the coordinate is a 4-dimensional vector, then no unused components |
| // may be added. |
| if (coordinate_type->AsVector() && |
| coordinate_type->AsVector()->element_count() == 4) { |
| return; |
| } |
| |
| // If the coordinate is a scalar, then at most 3 unused components may be |
| // added. If the coordinate is a vector, then the maximum number of unused |
| // components depends on the vector size. |
| // For the sample module, the coordinate type instruction is %5 = |
| // OpTypeVector %4 2, thus |max_unused_component_count| = 4 - 2 = 2. |
| uint32_t max_unused_component_count = |
| coordinate_type->AsInteger() || coordinate_type->AsFloat() |
| ? 3 |
| : 4 - coordinate_type->AsVector()->element_count(); |
| |
| // |unused_component_count| may be 1 or 2. |
| uint32_t unused_component_count = |
| GetFuzzerContext()->GetRandomUnusedComponentCountForImageSample( |
| max_unused_component_count); |
| |
| // Gets a type for the zero-unused components. |
| uint32_t zero_constant_type_id; |
| switch (unused_component_count) { |
| case 1: |
| // If the coordinate is an integer or float, then the unused components |
| // type is the same as the coordinate. If the coordinate is a vector, |
| // then the unused components type is the same as the vector components |
| // type. |
| zero_constant_type_id = |
| coordinate_type->AsInteger() || coordinate_type->AsFloat() |
| ? coordinate_instruction->type_id() |
| : GetIRContext()->get_type_mgr()->GetId( |
| coordinate_type->AsVector()->element_type()); |
| break; |
| case 2: |
| case 3: |
| // If the coordinate is an integer or float, then the unused components |
| // type is the same as the coordinate. If the coordinate is a vector, |
| // then the unused components type is the same as the coordinate |
| // components type. |
| // |zero_constant_type_id| %5 = OpTypeVector %4 2 |
| zero_constant_type_id = |
| coordinate_type->AsInteger() || coordinate_type->AsFloat() |
| ? FindOrCreateVectorType(coordinate_instruction->type_id(), |
| unused_component_count) |
| : FindOrCreateVectorType( |
| GetIRContext()->get_type_mgr()->GetId( |
| coordinate_type->AsVector()->element_type()), |
| unused_component_count); |
| break; |
| default: |
| assert(false && "Should be unreachable."); |
| zero_constant_type_id = 0; |
| break; |
| } |
| |
| // Gets |coordinate_type| again because the module may have changed due to |
| // the use of FindOrCreateVectorType above. |
| coordinate_type = GetIRContext()->get_type_mgr()->GetType( |
| coordinate_instruction->type_id()); |
| |
| // If the new vector type with unused components does not exist, then create |
| // it. |coordinate_with_unused_components_type_id| %6 = OpTypeVector %4 4 |
| uint32_t coordinate_with_unused_components_type_id = |
| coordinate_type->AsInteger() || coordinate_type->AsFloat() |
| ? FindOrCreateVectorType(coordinate_instruction->type_id(), |
| 1 + unused_component_count) |
| : FindOrCreateVectorType( |
| GetIRContext()->get_type_mgr()->GetId( |
| coordinate_type->AsVector()->element_type()), |
| coordinate_type->AsVector()->element_count() + |
| unused_component_count); |
| |
| // Inserts an OpCompositeConstruct instruction which |
| // represents the coordinate with unused components. |
| // |coordinate_with_unused_components_id| |
| // %22 = OpCompositeConstruct %6 %17 %21 |
| uint32_t coordinate_with_unused_components_id = |
| GetFuzzerContext()->GetFreshId(); |
| ApplyTransformation(TransformationCompositeConstruct( |
| coordinate_with_unused_components_type_id, |
| {coordinate_instruction->result_id(), |
| // FindOrCreateZeroConstant |
| // %20 = OpConstant %4 0 |
| // %21 = OpConstantComposite %5 %20 %20 |
| FindOrCreateZeroConstant(zero_constant_type_id, true)}, |
| MakeInstructionDescriptor(GetIRContext(), instruction), |
| coordinate_with_unused_components_id)); |
| |
| // Tries to add unused components to the image sample coordinate. |
| // %19 = OpImageSampleImplicitLod %6 %18 %22 |
| ApplyTransformation(TransformationAddImageSampleUnusedComponents( |
| coordinate_with_unused_components_id, |
| MakeInstructionDescriptor(GetIRContext(), instruction))); |
| }); |
| } |
| |
| } // namespace fuzz |
| } // namespace spvtools |
