xref: /third_party/spirv-tools/test/opt/loop_optimizations/nested_loops.cpp

// Copyright (c) 2017 Google Inc.
//
// 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 <memory>
#include <string>
#include <unordered_set>
#include <vector>

#include "gmock/gmock.h"
#include "source/opt/iterator.h"
#include "source/opt/loop_descriptor.h"
#include "source/opt/pass.h"
#include "source/opt/tree_iterator.h"
#include "test/opt/assembly_builder.h"
#include "test/opt/function_utils.h"
#include "test/opt/pass_fixture.h"
#include "test/opt/pass_utils.h"

namespace spvtools {
namespace opt {
namespace {

using ::testing::UnorderedElementsAre;

bool Validate(const std::vector<uint32_t>& bin) {
  spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2;
  spv_context spvContext = spvContextCreate(target_env);
  spv_diagnostic diagnostic = nullptr;
  spv_const_binary_t binary = {bin.data(), bin.size()};
  spv_result_t error = spvValidate(spvContext, &binary, &diagnostic);
  if (error != 0) spvDiagnosticPrint(diagnostic);
  spvDiagnosticDestroy(diagnostic);
  spvContextDestroy(spvContext);
  return error == 0;
}

using PassClassTest = PassTest<::testing::Test>;

/*
Generated from the following GLSL
#version 330 core
layout(location = 0) out vec4 c;
void main() {
  int i = 0;
  for (; i < 10; ++i) {
    int j = 0;
    int k = 0;
    for (; j < 11; ++j) {}
    for (; k < 12; ++k) {}
  }
}
*/
TEST_F(PassClassTest, BasicVisitFromEntryPoint) {
  const std::string text = R"(
               OpCapability Shader
          %1 = OpExtInstImport "GLSL.std.450"
               OpMemoryModel Logical GLSL450
               OpEntryPoint Fragment %2 "main" %3
               OpExecutionMode %2 OriginUpperLeft
               OpSource GLSL 330
               OpName %2 "main"
               OpName %4 "i"
               OpName %5 "j"
               OpName %6 "k"
               OpName %3 "c"
               OpDecorate %3 Location 0
          %7 = OpTypeVoid
          %8 = OpTypeFunction %7
          %9 = OpTypeInt 32 1
         %10 = OpTypePointer Function %9
         %11 = OpConstant %9 0
         %12 = OpConstant %9 10
         %13 = OpTypeBool
         %14 = OpConstant %9 11
         %15 = OpConstant %9 1
         %16 = OpConstant %9 12
         %17 = OpTypeFloat 32
         %18 = OpTypeVector %17 4
         %19 = OpTypePointer Output %18
          %3 = OpVariable %19 Output
          %2 = OpFunction %7 None %8
         %20 = OpLabel
          %4 = OpVariable %10 Function
          %5 = OpVariable %10 Function
          %6 = OpVariable %10 Function
               OpStore %4 %11
               OpBranch %21
         %21 = OpLabel
               OpLoopMerge %22 %23 None
               OpBranch %24
         %24 = OpLabel
         %25 = OpLoad %9 %4
         %26 = OpSLessThan %13 %25 %12
               OpBranchConditional %26 %27 %22
         %27 = OpLabel
               OpStore %5 %11
               OpStore %6 %11
               OpBranch %28
         %28 = OpLabel
               OpLoopMerge %29 %30 None
               OpBranch %31
         %31 = OpLabel
         %32 = OpLoad %9 %5
         %33 = OpSLessThan %13 %32 %14
               OpBranchConditional %33 %34 %29
         %34 = OpLabel
               OpBranch %30
         %30 = OpLabel
         %35 = OpLoad %9 %5
         %36 = OpIAdd %9 %35 %15
               OpStore %5 %36
               OpBranch %28
         %29 = OpLabel
               OpBranch %37
         %37 = OpLabel
               OpLoopMerge %38 %39 None
               OpBranch %40
         %40 = OpLabel
         %41 = OpLoad %9 %6
         %42 = OpSLessThan %13 %41 %16
               OpBranchConditional %42 %43 %38
         %43 = OpLabel
               OpBranch %39
         %39 = OpLabel
         %44 = OpLoad %9 %6
         %45 = OpIAdd %9 %44 %15
               OpStore %6 %45
               OpBranch %37
         %38 = OpLabel
               OpBranch %23
         %23 = OpLabel
         %46 = OpLoad %9 %4
         %47 = OpIAdd %9 %46 %15
               OpStore %4 %47
               OpBranch %21
         %22 = OpLabel
               OpReturn
               OpFunctionEnd
  )";
  // clang-format on
  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  Module* module = context->module();
  EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n"
                             << text << std::endl;
  const Function* f = spvtest::GetFunction(module, 2);
  LoopDescriptor& ld = *context->GetLoopDescriptor(f);

  EXPECT_EQ(ld.NumLoops(), 3u);

  // Invalid basic block id.
  EXPECT_EQ(ld[0u], nullptr);
  // Not a loop header.
  EXPECT_EQ(ld[20], nullptr);

  Loop& parent_loop = *ld[21];
  EXPECT_TRUE(parent_loop.HasNestedLoops());
  EXPECT_FALSE(parent_loop.IsNested());
  EXPECT_EQ(parent_loop.GetDepth(), 1u);
  EXPECT_EQ(std::distance(parent_loop.begin(), parent_loop.end()), 2u);
  EXPECT_EQ(parent_loop.GetHeaderBlock(), spvtest::GetBasicBlock(f, 21));
  EXPECT_EQ(parent_loop.GetLatchBlock(), spvtest::GetBasicBlock(f, 23));
  EXPECT_EQ(parent_loop.GetMergeBlock(), spvtest::GetBasicBlock(f, 22));

  Loop& child_loop_1 = *ld[28];
  EXPECT_FALSE(child_loop_1.HasNestedLoops());
  EXPECT_TRUE(child_loop_1.IsNested());
  EXPECT_EQ(child_loop_1.GetDepth(), 2u);
  EXPECT_EQ(std::distance(child_loop_1.begin(), child_loop_1.end()), 0u);
  EXPECT_EQ(child_loop_1.GetHeaderBlock(), spvtest::GetBasicBlock(f, 28));
  EXPECT_EQ(child_loop_1.GetLatchBlock(), spvtest::GetBasicBlock(f, 30));
  EXPECT_EQ(child_loop_1.GetMergeBlock(), spvtest::GetBasicBlock(f, 29));

  Loop& child_loop_2 = *ld[37];
  EXPECT_FALSE(child_loop_2.HasNestedLoops());
  EXPECT_TRUE(child_loop_2.IsNested());
  EXPECT_EQ(child_loop_2.GetDepth(), 2u);
  EXPECT_EQ(std::distance(child_loop_2.begin(), child_loop_2.end()), 0u);
  EXPECT_EQ(child_loop_2.GetHeaderBlock(), spvtest::GetBasicBlock(f, 37));
  EXPECT_EQ(child_loop_2.GetLatchBlock(), spvtest::GetBasicBlock(f, 39));
  EXPECT_EQ(child_loop_2.GetMergeBlock(), spvtest::GetBasicBlock(f, 38));
}

static void CheckLoopBlocks(Loop* loop,
                            std::unordered_set<uint32_t>* expected_ids) {
  SCOPED_TRACE("Check loop " + std::to_string(loop->GetHeaderBlock()->id()));
  for (uint32_t bb_id : loop->GetBlocks()) {
    EXPECT_EQ(expected_ids->count(bb_id), 1u);
    expected_ids->erase(bb_id);
  }
  EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock()));
  EXPECT_EQ(expected_ids->size(), 0u);
}

/*
Generated from the following GLSL
#version 330 core
layout(location = 0) out vec4 c;
void main() {
  int i = 0;
  for (; i < 10; ++i) {
    for (int j = 0; j < 11; ++j) {
      if (j < 5) {
        for (int k = 0; k < 12; ++k) {}
      }
      else {}
      for (int k = 0; k < 12; ++k) {}
    }
  }
}*/
TEST_F(PassClassTest, TripleNestedLoop) {
  const std::string text = R"(
               OpCapability Shader
          %1 = OpExtInstImport "GLSL.std.450"
               OpMemoryModel Logical GLSL450
               OpEntryPoint Fragment %2 "main" %3
               OpExecutionMode %2 OriginUpperLeft
               OpSource GLSL 330
               OpName %2 "main"
               OpName %4 "i"
               OpName %5 "j"
               OpName %6 "k"
               OpName %7 "k"
               OpName %3 "c"
               OpDecorate %3 Location 0
          %8 = OpTypeVoid
          %9 = OpTypeFunction %8
         %10 = OpTypeInt 32 1
         %11 = OpTypePointer Function %10
         %12 = OpConstant %10 0
         %13 = OpConstant %10 10
         %14 = OpTypeBool
         %15 = OpConstant %10 11
         %16 = OpConstant %10 5
         %17 = OpConstant %10 12
         %18 = OpConstant %10 1
         %19 = OpTypeFloat 32
         %20 = OpTypeVector %19 4
         %21 = OpTypePointer Output %20
          %3 = OpVariable %21 Output
          %2 = OpFunction %8 None %9
         %22 = OpLabel
          %4 = OpVariable %11 Function
          %5 = OpVariable %11 Function
          %6 = OpVariable %11 Function
          %7 = OpVariable %11 Function
               OpStore %4 %12
               OpBranch %23
         %23 = OpLabel
               OpLoopMerge %24 %25 None
               OpBranch %26
         %26 = OpLabel
         %27 = OpLoad %10 %4
         %28 = OpSLessThan %14 %27 %13
               OpBranchConditional %28 %29 %24
         %29 = OpLabel
               OpStore %5 %12
               OpBranch %30
         %30 = OpLabel
               OpLoopMerge %31 %32 None
               OpBranch %33
         %33 = OpLabel
         %34 = OpLoad %10 %5
         %35 = OpSLessThan %14 %34 %15
               OpBranchConditional %35 %36 %31
         %36 = OpLabel
         %37 = OpLoad %10 %5
         %38 = OpSLessThan %14 %37 %16
               OpSelectionMerge %39 None
               OpBranchConditional %38 %40 %39
         %40 = OpLabel
               OpStore %6 %12
               OpBranch %41
         %41 = OpLabel
               OpLoopMerge %42 %43 None
               OpBranch %44
         %44 = OpLabel
         %45 = OpLoad %10 %6
         %46 = OpSLessThan %14 %45 %17
               OpBranchConditional %46 %47 %42
         %47 = OpLabel
               OpBranch %43
         %43 = OpLabel
         %48 = OpLoad %10 %6
         %49 = OpIAdd %10 %48 %18
               OpStore %6 %49
               OpBranch %41
         %42 = OpLabel
               OpBranch %39
         %39 = OpLabel
               OpStore %7 %12
               OpBranch %50
         %50 = OpLabel
               OpLoopMerge %51 %52 None
               OpBranch %53
         %53 = OpLabel
         %54 = OpLoad %10 %7
         %55 = OpSLessThan %14 %54 %17
               OpBranchConditional %55 %56 %51
         %56 = OpLabel
               OpBranch %52
         %52 = OpLabel
         %57 = OpLoad %10 %7
         %58 = OpIAdd %10 %57 %18
               OpStore %7 %58
               OpBranch %50
         %51 = OpLabel
               OpBranch %32
         %32 = OpLabel
         %59 = OpLoad %10 %5
         %60 = OpIAdd %10 %59 %18
               OpStore %5 %60
               OpBranch %30
         %31 = OpLabel
               OpBranch %25
         %25 = OpLabel
         %61 = OpLoad %10 %4
         %62 = OpIAdd %10 %61 %18
               OpStore %4 %62
               OpBranch %23
         %24 = OpLabel
               OpReturn
               OpFunctionEnd
  )";
  // clang-format on
  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  Module* module = context->module();
  EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n"
                             << text << std::endl;
  const Function* f = spvtest::GetFunction(module, 2);
  LoopDescriptor& ld = *context->GetLoopDescriptor(f);

  EXPECT_EQ(ld.NumLoops(), 4u);

  // Invalid basic block id.
  EXPECT_EQ(ld[0u], nullptr);
  // Not in a loop.
  EXPECT_EQ(ld[22], nullptr);

  // Check that we can map basic block to the correct loop.
  // The following block ids do not belong to a loop.
  for (uint32_t bb_id : {22, 24}) EXPECT_EQ(ld[bb_id], nullptr);

  {
    std::unordered_set<uint32_t> basic_block_in_loop = {
        {23, 26, 29, 30, 33, 36, 40, 41, 44, 47, 43,
         42, 39, 50, 53, 56, 52, 51, 32, 31, 25}};
    Loop* loop = ld[23];
    CheckLoopBlocks(loop, &basic_block_in_loop);

    EXPECT_TRUE(loop->HasNestedLoops());
    EXPECT_FALSE(loop->IsNested());
    EXPECT_EQ(loop->GetDepth(), 1u);
    EXPECT_EQ(std::distance(loop->begin(), loop->end()), 1u);
    EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 22));
    EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 23));
    EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 25));
    EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 24));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock()));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock()));
  }

  {
    std::unordered_set<uint32_t> basic_block_in_loop = {
        {30, 33, 36, 40, 41, 44, 47, 43, 42, 39, 50, 53, 56, 52, 51, 32}};
    Loop* loop = ld[30];
    CheckLoopBlocks(loop, &basic_block_in_loop);

    EXPECT_TRUE(loop->HasNestedLoops());
    EXPECT_TRUE(loop->IsNested());
    EXPECT_EQ(loop->GetDepth(), 2u);
    EXPECT_EQ(std::distance(loop->begin(), loop->end()), 2u);
    EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 29));
    EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 30));
    EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 32));
    EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 31));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock()));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock()));
  }

  {
    std::unordered_set<uint32_t> basic_block_in_loop = {{41, 44, 47, 43}};
    Loop* loop = ld[41];
    CheckLoopBlocks(loop, &basic_block_in_loop);

    EXPECT_FALSE(loop->HasNestedLoops());
    EXPECT_TRUE(loop->IsNested());
    EXPECT_EQ(loop->GetDepth(), 3u);
    EXPECT_EQ(std::distance(loop->begin(), loop->end()), 0u);
    EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 40));
    EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 41));
    EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 43));
    EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 42));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock()));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock()));
  }

  {
    std::unordered_set<uint32_t> basic_block_in_loop = {{50, 53, 56, 52}};
    Loop* loop = ld[50];
    CheckLoopBlocks(loop, &basic_block_in_loop);

    EXPECT_FALSE(loop->HasNestedLoops());
    EXPECT_TRUE(loop->IsNested());
    EXPECT_EQ(loop->GetDepth(), 3u);
    EXPECT_EQ(std::distance(loop->begin(), loop->end()), 0u);
    EXPECT_EQ(loop->GetPreHeaderBlock(), spvtest::GetBasicBlock(f, 39));
    EXPECT_EQ(loop->GetHeaderBlock(), spvtest::GetBasicBlock(f, 50));
    EXPECT_EQ(loop->GetLatchBlock(), spvtest::GetBasicBlock(f, 52));
    EXPECT_EQ(loop->GetMergeBlock(), spvtest::GetBasicBlock(f, 51));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetMergeBlock()));
    EXPECT_FALSE(loop->IsInsideLoop(loop->GetPreHeaderBlock()));
  }

  // Make sure LoopDescriptor gives us the inner most loop when we query for
  // loops.
  for (const BasicBlock& bb : *f) {
    if (Loop* loop = ld[&bb]) {
      for (Loop& sub_loop :
           make_range(++TreeDFIterator<Loop>(loop), TreeDFIterator<Loop>())) {
        EXPECT_FALSE(sub_loop.IsInsideLoop(bb.id()));
      }
    }
  }
}

/*
Generated from the following GLSL
#version 330 core
layout(location = 0) out vec4 c;
void main() {
  for (int i = 0; i < 10; ++i) {
    for (int j = 0; j < 11; ++j) {
      for (int k = 0; k < 11; ++k) {}
    }
    for (int k = 0; k < 12; ++k) {}
  }
}
*/
TEST_F(PassClassTest, LoopParentTest) {
  const std::string text = R"(
               OpCapability Shader
          %1 = OpExtInstImport "GLSL.std.450"
               OpMemoryModel Logical GLSL450
               OpEntryPoint Fragment %2 "main" %3
               OpExecutionMode %2 OriginUpperLeft
               OpSource GLSL 330
               OpName %2 "main"
               OpName %4 "i"
               OpName %5 "j"
               OpName %6 "k"
               OpName %7 "k"
               OpName %3 "c"
               OpDecorate %3 Location 0
          %8 = OpTypeVoid
          %9 = OpTypeFunction %8
         %10 = OpTypeInt 32 1
         %11 = OpTypePointer Function %10
         %12 = OpConstant %10 0
         %13 = OpConstant %10 10
         %14 = OpTypeBool
         %15 = OpConstant %10 11
         %16 = OpConstant %10 1
         %17 = OpConstant %10 12
         %18 = OpTypeFloat 32
         %19 = OpTypeVector %18 4
         %20 = OpTypePointer Output %19
          %3 = OpVariable %20 Output
          %2 = OpFunction %8 None %9
         %21 = OpLabel
          %4 = OpVariable %11 Function
          %5 = OpVariable %11 Function
          %6 = OpVariable %11 Function
          %7 = OpVariable %11 Function
               OpStore %4 %12
               OpBranch %22
         %22 = OpLabel
               OpLoopMerge %23 %24 None
               OpBranch %25
         %25 = OpLabel
         %26 = OpLoad %10 %4
         %27 = OpSLessThan %14 %26 %13
               OpBranchConditional %27 %28 %23
         %28 = OpLabel
               OpStore %5 %12
               OpBranch %29
         %29 = OpLabel
               OpLoopMerge %30 %31 None
               OpBranch %32
         %32 = OpLabel
         %33 = OpLoad %10 %5
         %34 = OpSLessThan %14 %33 %15
               OpBranchConditional %34 %35 %30
         %35 = OpLabel
               OpStore %6 %12
               OpBranch %36
         %36 = OpLabel
               OpLoopMerge %37 %38 None
               OpBranch %39
         %39 = OpLabel
         %40 = OpLoad %10 %6
         %41 = OpSLessThan %14 %40 %15
               OpBranchConditional %41 %42 %37
         %42 = OpLabel
               OpBranch %38
         %38 = OpLabel
         %43 = OpLoad %10 %6
         %44 = OpIAdd %10 %43 %16
               OpStore %6 %44
               OpBranch %36
         %37 = OpLabel
               OpBranch %31
         %31 = OpLabel
         %45 = OpLoad %10 %5
         %46 = OpIAdd %10 %45 %16
               OpStore %5 %46
               OpBranch %29
         %30 = OpLabel
               OpStore %7 %12
               OpBranch %47
         %47 = OpLabel
               OpLoopMerge %48 %49 None
               OpBranch %50
         %50 = OpLabel
         %51 = OpLoad %10 %7
         %52 = OpSLessThan %14 %51 %17
               OpBranchConditional %52 %53 %48
         %53 = OpLabel
               OpBranch %49
         %49 = OpLabel
         %54 = OpLoad %10 %7
         %55 = OpIAdd %10 %54 %16
               OpStore %7 %55
               OpBranch %47
         %48 = OpLabel
               OpBranch %24
         %24 = OpLabel
         %56 = OpLoad %10 %4
         %57 = OpIAdd %10 %56 %16
               OpStore %4 %57
               OpBranch %22
         %23 = OpLabel
               OpReturn
               OpFunctionEnd
  )";
  // clang-format on
  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  Module* module = context->module();
  EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n"
                             << text << std::endl;
  const Function* f = spvtest::GetFunction(module, 2);
  LoopDescriptor& ld = *context->GetLoopDescriptor(f);

  EXPECT_EQ(ld.NumLoops(), 4u);

  {
    Loop& loop = *ld[22];
    EXPECT_TRUE(loop.HasNestedLoops());
    EXPECT_FALSE(loop.IsNested());
    EXPECT_EQ(loop.GetDepth(), 1u);
    EXPECT_EQ(loop.GetParent(), nullptr);
  }

  {
    Loop& loop = *ld[29];
    EXPECT_TRUE(loop.HasNestedLoops());
    EXPECT_TRUE(loop.IsNested());
    EXPECT_EQ(loop.GetDepth(), 2u);
    EXPECT_EQ(loop.GetParent(), ld[22]);
  }

  {
    Loop& loop = *ld[36];
    EXPECT_FALSE(loop.HasNestedLoops());
    EXPECT_TRUE(loop.IsNested());
    EXPECT_EQ(loop.GetDepth(), 3u);
    EXPECT_EQ(loop.GetParent(), ld[29]);
  }

  {
    Loop& loop = *ld[47];
    EXPECT_FALSE(loop.HasNestedLoops());
    EXPECT_TRUE(loop.IsNested());
    EXPECT_EQ(loop.GetDepth(), 2u);
    EXPECT_EQ(loop.GetParent(), ld[22]);
  }
}

/*
Generated from the following GLSL + --eliminate-local-multi-store
The preheader of loop %33 and %41 were removed as well.

#version 330 core
void main() {
  int a = 0;
  for (int i = 0; i < 10; ++i) {
    if (i == 0) {
      a = 1;
    } else {
      a = 2;
    }
    for (int j = 0; j < 11; ++j) {
      a++;
    }
  }
  for (int k = 0; k < 12; ++k) {}
}
*/
TEST_F(PassClassTest, CreatePreheaderTest) {
  const std::string text = R"(
               OpCapability Shader
          %1 = OpExtInstImport "GLSL.std.450"
               OpMemoryModel Logical GLSL450
               OpEntryPoint Fragment %2 "main"
               OpExecutionMode %2 OriginUpperLeft
               OpSource GLSL 330
               OpName %2 "main"
          %3 = OpTypeVoid
          %4 = OpTypeFunction %3
          %5 = OpTypeInt 32 1
          %6 = OpTypePointer Function %5
          %7 = OpConstant %5 0
          %8 = OpConstant %5 10
          %9 = OpTypeBool
         %10 = OpConstant %5 1
         %11 = OpConstant %5 2
         %12 = OpConstant %5 11
         %13 = OpConstant %5 12
         %14 = OpUndef %5
          %2 = OpFunction %3 None %4
         %15 = OpLabel
               OpBranch %16
         %16 = OpLabel
         %17 = OpPhi %5 %7 %15 %18 %19
         %20 = OpPhi %5 %7 %15 %21 %19
         %22 = OpPhi %5 %14 %15 %23 %19
               OpLoopMerge %41 %19 None
               OpBranch %25
         %25 = OpLabel
         %26 = OpSLessThan %9 %20 %8
               OpBranchConditional %26 %27 %41
         %27 = OpLabel
         %28 = OpIEqual %9 %20 %7
               OpSelectionMerge %33 None
               OpBranchConditional %28 %30 %31
         %30 = OpLabel
               OpBranch %33
         %31 = OpLabel
               OpBranch %33
         %33 = OpLabel
         %18 = OpPhi %5 %10 %30 %11 %31 %34 %35
         %23 = OpPhi %5 %7 %30 %7 %31 %36 %35
               OpLoopMerge %37 %35 None
               OpBranch %38
         %38 = OpLabel
         %39 = OpSLessThan %9 %23 %12
               OpBranchConditional %39 %40 %37
         %40 = OpLabel
         %34 = OpIAdd %5 %18 %10
               OpBranch %35
         %35 = OpLabel
         %36 = OpIAdd %5 %23 %10
               OpBranch %33
         %37 = OpLabel
               OpBranch %19
         %19 = OpLabel
         %21 = OpIAdd %5 %20 %10
               OpBranch %16
         %41 = OpLabel
         %42 = OpPhi %5 %7 %25 %43 %44
               OpLoopMerge %45 %44 None
               OpBranch %46
         %46 = OpLabel
         %47 = OpSLessThan %9 %42 %13
               OpBranchConditional %47 %48 %45
         %48 = OpLabel
               OpBranch %44
         %44 = OpLabel
         %43 = OpIAdd %5 %42 %10
               OpBranch %41
         %45 = OpLabel
               OpReturn
               OpFunctionEnd
  )";
  // clang-format on
  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  Module* module = context->module();
  EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n"
                             << text << std::endl;
  const Function* f = spvtest::GetFunction(module, 2);
  LoopDescriptor& ld = *context->GetLoopDescriptor(f);
  // No invalidation of the cfg should occur during this test.
  CFG* cfg = context->cfg();

  EXPECT_EQ(ld.NumLoops(), 3u);

  {
    Loop& loop = *ld[16];
    EXPECT_TRUE(loop.HasNestedLoops());
    EXPECT_FALSE(loop.IsNested());
    EXPECT_EQ(loop.GetDepth(), 1u);
    EXPECT_EQ(loop.GetParent(), nullptr);
  }

  {
    Loop& loop = *ld[33];
    EXPECT_EQ(loop.GetPreHeaderBlock(), nullptr);
    EXPECT_NE(loop.GetOrCreatePreHeaderBlock(), nullptr);
    // Make sure the loop descriptor was properly updated.
    EXPECT_EQ(ld[loop.GetPreHeaderBlock()], ld[16]);
    {
      const std::vector<uint32_t>& preds =
          cfg->preds(loop.GetPreHeaderBlock()->id());
      std::unordered_set<uint32_t> pred_set(preds.begin(), preds.end());
      EXPECT_EQ(pred_set.size(), 2u);
      EXPECT_TRUE(pred_set.count(30));
      EXPECT_TRUE(pred_set.count(31));
      // Check the phi instructions.
      loop.GetPreHeaderBlock()->ForEachPhiInst([&pred_set](Instruction* phi) {
        for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) {
          EXPECT_TRUE(pred_set.count(phi->GetSingleWordInOperand(i)));
        }
      });
    }
    {
      const std::vector<uint32_t>& preds =
          cfg->preds(loop.GetHeaderBlock()->id());
      std::unordered_set<uint32_t> pred_set(preds.begin(), preds.end());
      EXPECT_EQ(pred_set.size(), 2u);
      EXPECT_TRUE(pred_set.count(loop.GetPreHeaderBlock()->id()));
      EXPECT_TRUE(pred_set.count(35));
      // Check the phi instructions.
      loop.GetHeaderBlock()->ForEachPhiInst([&pred_set](Instruction* phi) {
        for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) {
          EXPECT_TRUE(pred_set.count(phi->GetSingleWordInOperand(i)));
        }
      });
    }
  }

  {
    Loop& loop = *ld[41];
    EXPECT_EQ(loop.GetPreHeaderBlock(), nullptr);
    EXPECT_NE(loop.GetOrCreatePreHeaderBlock(), nullptr);
    EXPECT_EQ(ld[loop.GetPreHeaderBlock()], nullptr);
    EXPECT_EQ(cfg->preds(loop.GetPreHeaderBlock()->id()).size(), 1u);
    EXPECT_EQ(cfg->preds(loop.GetPreHeaderBlock()->id())[0], 25u);
    // Check the phi instructions.
    loop.GetPreHeaderBlock()->ForEachPhiInst([](Instruction* phi) {
      EXPECT_EQ(phi->NumInOperands(), 2u);
      EXPECT_EQ(phi->GetSingleWordInOperand(1), 25u);
    });
    {
      const std::vector<uint32_t>& preds =
          cfg->preds(loop.GetHeaderBlock()->id());
      std::unordered_set<uint32_t> pred_set(preds.begin(), preds.end());
      EXPECT_EQ(pred_set.size(), 2u);
      EXPECT_TRUE(pred_set.count(loop.GetPreHeaderBlock()->id()));
      EXPECT_TRUE(pred_set.count(44));
      // Check the phi instructions.
      loop.GetHeaderBlock()->ForEachPhiInst([&pred_set](Instruction* phi) {
        for (uint32_t i = 1; i < phi->NumInOperands(); i += 2) {
          EXPECT_TRUE(pred_set.count(phi->GetSingleWordInOperand(i)));
        }
      });
    }
  }

  // Make sure pre-header insertion leaves the module valid.
  std::vector<uint32_t> bin;
  context->module()->ToBinary(&bin, true);
  EXPECT_TRUE(Validate(bin));
}

}  // namespace
}  // namespace opt
}  // namespace spvtools