SPIRV-Tools/test/fuzz/fuzzer_pass_add_opphi_synonyms_test.cpp

177 lines
6.2 KiB
C++
Raw Normal View History

// Copyright (c) 2020 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.
#include "source/fuzz/fuzzer_pass_add_opphi_synonyms.h"
#include "gtest/gtest.h"
#include "source/fuzz/fuzzer_util.h"
#include "source/fuzz/pseudo_random_generator.h"
#include "test/fuzz/fuzz_test_util.h"
namespace spvtools {
namespace fuzz {
namespace {
protobufs::Fact MakeSynonymFact(uint32_t first, uint32_t second) {
protobufs::FactDataSynonym data_synonym_fact;
*data_synonym_fact.mutable_data1() = MakeDataDescriptor(first, {});
*data_synonym_fact.mutable_data2() = MakeDataDescriptor(second, {});
protobufs::Fact result;
*result.mutable_data_synonym_fact() = data_synonym_fact;
return result;
}
// Adds synonym facts to the fact manager.
void SetUpIdSynonyms(FactManager* fact_manager) {
// Synonyms {9, 11, 15, 16, 21, 22}
fact_manager->MaybeAddFact(MakeSynonymFact(11, 9));
fact_manager->MaybeAddFact(MakeSynonymFact(15, 9));
fact_manager->MaybeAddFact(MakeSynonymFact(16, 9));
fact_manager->MaybeAddFact(MakeSynonymFact(21, 9));
fact_manager->MaybeAddFact(MakeSynonymFact(22, 9));
// Synonyms {10, 23}
fact_manager->MaybeAddFact(MakeSynonymFact(10, 23));
// Synonyms {14, 27}
fact_manager->MaybeAddFact(MakeSynonymFact(14, 27));
// Synonyms {24, 26, 30}
fact_manager->MaybeAddFact(MakeSynonymFact(26, 24));
fact_manager->MaybeAddFact(MakeSynonymFact(30, 24));
}
// Returns true if the given lists have the same elements, regardless of their
// order.
template <typename T>
bool ListsHaveTheSameElements(const std::vector<T>& list1,
const std::vector<T>& list2) {
auto sorted1 = list1;
std::sort(sorted1.begin(), sorted1.end());
auto sorted2 = list2;
std::sort(sorted2.begin(), sorted2.end());
return sorted1 == sorted2;
}
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
OpName %2 "main"
%3 = OpTypeVoid
%4 = OpTypeFunction %3
%5 = OpTypeBool
%6 = OpConstantTrue %5
%7 = OpTypeInt 32 1
%31 = OpTypeFunction %7
%8 = OpTypeInt 32 0
%9 = OpConstant %7 1
%10 = OpConstant %7 2
%11 = OpConstant %8 1
%12 = OpTypePointer Function %7
%2 = OpFunction %3 None %4
%13 = OpLabel
%14 = OpVariable %12 Function
%15 = OpCopyObject %7 %9
%16 = OpCopyObject %8 %11
OpBranch %17
%17 = OpLabel
OpSelectionMerge %18 None
OpBranchConditional %6 %19 %20
%19 = OpLabel
%21 = OpCopyObject %7 %15
%22 = OpCopyObject %8 %16
%23 = OpCopyObject %7 %10
%24 = OpIAdd %7 %9 %10
OpBranch %18
%20 = OpLabel
OpBranch %18
%18 = OpLabel
%26 = OpIAdd %7 %15 %10
%27 = OpCopyObject %12 %14
OpSelectionMerge %28 None
OpBranchConditional %6 %29 %28
%29 = OpLabel
%30 = OpCopyObject %7 %26
OpBranch %28
%28 = OpLabel
OpReturn
OpFunctionEnd
%32 = OpFunction %7 None %31
%33 = OpLabel
OpReturnValue %9
OpFunctionEnd
)";
TEST(FuzzerPassAddOpPhiSynonymsTest, HelperFunctions) {
const auto env = SPV_ENV_UNIVERSAL_1_5;
const auto consumer = nullptr;
const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
spvtools::ValidatorOptions validator_options;
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
FuzzerContext fuzzer_context(MakeUnique<PseudoRandomGenerator>(0), 100,
false);
protobufs::TransformationSequence transformation_sequence;
FuzzerPassAddOpPhiSynonyms fuzzer_pass(context.get(), &transformation_context,
&fuzzer_context,
&transformation_sequence, false);
SetUpIdSynonyms(transformation_context.GetFactManager());
std::vector<std::set<uint32_t>> expected_equivalence_classes = {
{9, 15, 21}, {11, 16, 22}, {10, 23}, {6}, {24, 26, 30}};
ASSERT_TRUE(ListsHaveTheSameElements<std::set<uint32_t>>(
fuzzer_pass.GetIdEquivalenceClasses(), expected_equivalence_classes));
// The set {24, 26, 30} is not suitable for 18 (none if the ids is available
// for predecessor 20).
ASSERT_FALSE(
fuzzer_pass.EquivalenceClassIsSuitableForBlock({24, 26, 30}, 18, 1));
// The set {6} is not suitable for 18 if we require at least 2 distinct
// available ids.
ASSERT_FALSE(fuzzer_pass.EquivalenceClassIsSuitableForBlock({6}, 18, 2));
// Only id 26 from the set {24, 26, 30} is available to use for the
// transformation at block 29, so the set is not suitable if we want at least
// 2 available ids.
ASSERT_FALSE(
fuzzer_pass.EquivalenceClassIsSuitableForBlock({24, 26, 30}, 29, 2));
ASSERT_TRUE(
fuzzer_pass.EquivalenceClassIsSuitableForBlock({24, 26, 30}, 29, 1));
// %21 is not available at the end of block 20.
ASSERT_TRUE(ListsHaveTheSameElements<uint32_t>(
fuzzer_pass.GetSuitableIds({9, 15, 21}, 20), {9, 15}));
// %24 and %30 are not available at the end of block 18.
ASSERT_TRUE(ListsHaveTheSameElements<uint32_t>(
fuzzer_pass.GetSuitableIds({24, 26, 30}, 18), {26}));
}
} // namespace
} // namespace fuzz
} // namespace spvtools