// Copyright (c) 2018 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 <algorithm>

#include <memory>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <vector>

#include "source/cfa.h"

#include "source/opt/cfg.h"

#include "source/opt/ir_builder.h"

#include "source/opt/ir_context.h"

#include "source/opt/loop_descriptor.h"

#include "source/opt/loop_utils.h"

namespace spvtools {

namespace opt {

namespace {

// Return true if |bb| is dominated by at least one block in |exits|

inline bool DominatesAnExit(BasicBlock* bb,

                            const std::unordered_set<BasicBlock*>& exits,

                            const DominatorTree& dom_tree) {

  for (BasicBlock* e_bb : exits)

    if (dom_tree.Dominates(bb, e_bb)) return true;

  return false;

}

// Utility class to rewrite out-of-loop uses of an in-loop definition in terms

// of phi instructions to achieve a LCSSA form.

// For a given definition, the class user registers phi instructions using that

// definition in all loop exit blocks by which the definition escapes.

// Then, when rewriting a use of the definition, the rewriter walks the

// paths from the use the loop exits. At each step, it will insert a phi

// instruction to merge the incoming value according to exit blocks definition.

class LCSSARewriter {

 public:

  LCSSARewriter(IRContext* context, const DominatorTree& dom_tree,

                const std::unordered_set<BasicBlock*>& exit_bb,

                BasicBlock* merge_block)

      : context_(context),

        cfg_(context_->cfg()),

        dom_tree_(dom_tree),

        exit_bb_(exit_bb),

        merge_block_id_(merge_block ? merge_block->id() : 0) {}

  struct UseRewriter {

    explicit UseRewriter(LCSSARewriter* base, const Instruction& def_insn)

        : base_(base), def_insn_(def_insn) {}

    // Rewrites the use of |def_insn_| by the instruction |user| at the index

    // |operand_index| in terms of phi instruction. This recursively builds new

    // phi instructions from |user| to the loop exit blocks' phis. The use of

    // |def_insn_| in |user| is replaced by the relevant phi instruction at the

    // end of the operation.

    // It is assumed that |user| does not dominates any of the loop exit basic

    // block. This operation does not update the def/use manager, instead it

    // records what needs to be updated. The actual update is performed by

    // UpdateManagers.

    void RewriteUse(BasicBlock* bb, Instruction* user, uint32_t operand_index) {

      assert(

          (user->opcode() != spv::Op::OpPhi || bb != GetParent(user)) &&

          "The root basic block must be the incoming edge if |user| is a phi "

          "instruction");

      assert((user->opcode() == spv::Op::OpPhi || bb == GetParent(user)) &&

             "The root basic block must be the instruction parent if |user| is "

             "not "

             "phi instruction");

      Instruction* new_def = GetOrBuildIncoming(bb->id());

      user->SetOperand(operand_index, {new_def->result_id()});

      rewritten_.insert(user);

    }

    // In-place update of some managers (avoid full invalidation).

    inline void UpdateManagers() {

      analysis::DefUseManager* def_use_mgr = base_->context_->get_def_use_mgr();

      // Register all new definitions.

      for (Instruction* insn : rewritten_) {

        def_use_mgr->AnalyzeInstDef(insn);

      }

      // Register all new uses.

      for (Instruction* insn : rewritten_) {

        def_use_mgr->AnalyzeInstUse(insn);

      }

    }

   private:

    // Return the basic block that |instr| belongs to.

    BasicBlock* GetParent(Instruction* instr) {

      return base_->context_->get_instr_block(instr);

    }

    // Builds a phi instruction for the basic block |bb|. The function assumes

    // that |defining_blocks| contains the list of basic block that define the

    // usable value for each predecessor of |bb|.

    inline Instruction* CreatePhiInstruction(

        BasicBlock* bb, const std::vector<uint32_t>& defining_blocks) {

      std::vector<uint32_t> incomings;

      const std::vector<uint32_t>& bb_preds = base_->cfg_->preds(bb->id());

      assert(bb_preds.size() == defining_blocks.size());

      for (size_t i = 0; i < bb_preds.size(); i++) {

        incomings.push_back(

            GetOrBuildIncoming(defining_blocks[i])->result_id());

        incomings.push_back(bb_preds[i]);

      }

      InstructionBuilder builder(base_->context_, &*bb->begin(),

                                 IRContext::kAnalysisInstrToBlockMapping);

      Instruction* incoming_phi =

          builder.AddPhi(def_insn_.type_id(), incomings);

      rewritten_.insert(incoming_phi);

      return incoming_phi;

    }

    // Builds a phi instruction for the basic block |bb|, all incoming values

    // will be |value|.

    inline Instruction* CreatePhiInstruction(BasicBlock* bb,

                                             const Instruction& value) {

      std::vector<uint32_t> incomings;

      const std::vector<uint32_t>& bb_preds = base_->cfg_->preds(bb->id());

      for (size_t i = 0; i < bb_preds.size(); i++) {

        incomings.push_back(value.result_id());

        incomings.push_back(bb_preds[i]);

      }

      InstructionBuilder builder(base_->context_, &*bb->begin(),

                                 IRContext::kAnalysisInstrToBlockMapping);

      Instruction* incoming_phi =

          builder.AddPhi(def_insn_.type_id(), incomings);

      rewritten_.insert(incoming_phi);

      return incoming_phi;

    }

    // Return the new def to use for the basic block |bb_id|.

    // If |bb_id| does not have a suitable def to use then we:

    //   - return the common def used by all predecessors;

    //   - if there is no common def, then we build a new phi instr at the

    //     beginning of |bb_id| and return this new instruction.

    Instruction* GetOrBuildIncoming(uint32_t bb_id) {

      assert(base_->cfg_->block(bb_id) != nullptr && "Unknown basic block");

      Instruction*& incoming_phi = bb_to_phi_[bb_id];

      if (incoming_phi) {

        return incoming_phi;

      }

      BasicBlock* bb = &*base_->cfg_->block(bb_id);

      // If this is an exit basic block, look if there already is an eligible

      // phi instruction. An eligible phi has |def_insn_| as all incoming

      // values.

      if (base_->exit_bb_.count(bb)) {

        // Look if there is an eligible phi in this block.

        if (!bb->WhileEachPhiInst([&incoming_phi, this](Instruction* phi) {

              for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) {

                if (phi->GetSingleWordInOperand(i) != def_insn_.result_id())

                  return true;

              }

              incoming_phi = phi;

              rewritten_.insert(incoming_phi);

              return false;

            })) {

          return incoming_phi;

        }

        incoming_phi = CreatePhiInstruction(bb, def_insn_);

        return incoming_phi;

      }

      // Get the block that defines the value to use for each predecessor.

      // If the vector has 1 value, then it means that this block does not need

      // to build a phi instruction unless |bb_id| is the loop merge block.

      const std::vector<uint32_t>& defining_blocks =

          base_->GetDefiningBlocks(bb_id);

      // Special case for structured loops: merge block might be different from

      // the exit block set. To maintain structured properties it will ease

      // transformations if the merge block also holds a phi instruction like

      // the exit ones.

      if (defining_blocks.size() > 1 || bb_id == base_->merge_block_id_) {

        if (defining_blocks.size() > 1) {

          incoming_phi = CreatePhiInstruction(bb, defining_blocks);

        } else {

          assert(bb_id == base_->merge_block_id_);

          incoming_phi =

              CreatePhiInstruction(bb, *GetOrBuildIncoming(defining_blocks[0]));

        }

      } else {

        incoming_phi = GetOrBuildIncoming(defining_blocks[0]);

      }

      return incoming_phi;

    }

    LCSSARewriter* base_;

    const Instruction& def_insn_;

    std::unordered_map<uint32_t, Instruction*> bb_to_phi_;

    std::unordered_set<Instruction*> rewritten_;

  };

 private:

  // Return the new def to use for the basic block |bb_id|.

  // If |bb_id| does not have a suitable def to use then we:

  //   - return the common def used by all predecessors;

  //   - if there is no common def, then we build a new phi instr at the

  //     beginning of |bb_id| and return this new instruction.

  const std::vector<uint32_t>& GetDefiningBlocks(uint32_t bb_id) {

    assert(cfg_->block(bb_id) != nullptr && "Unknown basic block");

    std::vector<uint32_t>& defining_blocks = bb_to_defining_blocks_[bb_id];

    if (defining_blocks.size()) return defining_blocks;

    // Check if one of the loop exit basic block dominates |bb_id|.

    for (const BasicBlock* e_bb : exit_bb_) {

      if (dom_tree_.Dominates(e_bb->id(), bb_id)) {

        defining_blocks.push_back(e_bb->id());

        return defining_blocks;

      }

    }

    // Process parents, they will returns their suitable blocks.

    // If they are all the same, this means this basic block is dominated by a

    // common block, so we won't need to build a phi instruction.

    for (uint32_t pred_id : cfg_->preds(bb_id)) {

      const std::vector<uint32_t>& pred_blocks = GetDefiningBlocks(pred_id);

      if (pred_blocks.size() == 1)

        defining_blocks.push_back(pred_blocks[0]);

      else

        defining_blocks.push_back(pred_id);

    }

    assert(defining_blocks.size());

    if (std::all_of(defining_blocks.begin(), defining_blocks.end(),

                    [&defining_blocks](uint32_t id) {

                      return id == defining_blocks[0];

                    })) {

      // No need for a phi.

      defining_blocks.resize(1);

    }

    return defining_blocks;

  }

  IRContext* context_;

  CFG* cfg_;

  const DominatorTree& dom_tree_;

  const std::unordered_set<BasicBlock*>& exit_bb_;

  uint32_t merge_block_id_;

  // This map represent the set of known paths. For each key, the vector

  // represent the set of blocks holding the definition to be used to build the

  // phi instruction.

  // If the vector has 0 value, then the path is unknown yet, and must be built.

  // If the vector has 1 value, then the value defined by that basic block

  //   should be used.

  // If the vector has more than 1 value, then a phi node must be created, the

  //   basic block ordering is the same as the predecessor ordering.

  std::unordered_map<uint32_t, std::vector<uint32_t>> bb_to_defining_blocks_;

};

// Make the set |blocks| closed SSA. The set is closed SSA if all the uses

// outside the set are phi instructions in exiting basic block set (hold by

// |lcssa_rewriter|).

inline void MakeSetClosedSSA(IRContext* context, Function* function,

                             const std::unordered_set<uint32_t>& blocks,

                             const std::unordered_set<BasicBlock*>& exit_bb,

                             LCSSARewriter* lcssa_rewriter) {

  CFG& cfg = *context->cfg();

  DominatorTree& dom_tree =

      context->GetDominatorAnalysis(function)->GetDomTree();

  analysis::DefUseManager* def_use_manager = context->get_def_use_mgr();

  for (uint32_t bb_id : blocks) {

    BasicBlock* bb = cfg.block(bb_id);

    // If bb does not dominate an exit block, then it cannot have escaping defs.

    if (!DominatesAnExit(bb, exit_bb, dom_tree)) continue;

    for (Instruction& inst : *bb) {

      LCSSARewriter::UseRewriter rewriter(lcssa_rewriter, inst);

      def_use_manager->ForEachUse(

          &inst, [&blocks, &rewriter, &exit_bb, context](

                     Instruction* use, uint32_t operand_index) {

            BasicBlock* use_parent = context->get_instr_block(use);

            assert(use_parent);

            if (blocks.count(use_parent->id())) return;

            if (use->opcode() == spv::Op::OpPhi) {

              // If the use is a Phi instruction and the incoming block is

              // coming from the loop, then that's consistent with LCSSA form.

              if (exit_bb.count(use_parent)) {

                return;

              } else {

                // That's not an exit block, but the user is a phi instruction.

                // Consider the incoming branch only.

                use_parent = context->get_instr_block(

                    use->GetSingleWordOperand(operand_index + 1));

              }

            }

            // Rewrite the use. Note that this call does not invalidate the

            // def/use manager. So this operation is safe.

            rewriter.RewriteUse(use_parent, use, operand_index);

          });

      rewriter.UpdateManagers();

    }

  }

}

}  // namespace

void LoopUtils::CreateLoopDedicatedExits() {

  Function* function = loop_->GetHeaderBlock()->GetParent();

  LoopDescriptor& loop_desc = *context_->GetLoopDescriptor(function);

  CFG& cfg = *context_->cfg();

  analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr();

  const IRContext::Analysis PreservedAnalyses =

      IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping;

  // Gathers the set of basic block that are not in this loop and have at least

  // one predecessor in the loop and one not in the loop.

  std::unordered_set<uint32_t> exit_bb_set;

  loop_->GetExitBlocks(&exit_bb_set);

  std::unordered_set<BasicBlock*> new_loop_exits;

  bool made_change = false;

  // For each block, we create a new one that gathers all branches from

  // the loop and fall into the block.

  for (uint32_t non_dedicate_id : exit_bb_set) {

    BasicBlock* non_dedicate = cfg.block(non_dedicate_id);

    const std::vector<uint32_t>& bb_pred = cfg.preds(non_dedicate_id);

    // Ignore the block if all the predecessors are in the loop.

    if (std::all_of(bb_pred.begin(), bb_pred.end(),

                    [this](uint32_t id) { return loop_->IsInsideLoop(id); })) {

      new_loop_exits.insert(non_dedicate);

      continue;

    }

    made_change = true;

    Function::iterator insert_pt = function->begin();

    for (; insert_pt != function->end() && &*insert_pt != non_dedicate;

         ++insert_pt) {

    }

    assert(insert_pt != function->end() && "Basic Block not found");

    // Create the dedicate exit basic block.

    // TODO(1841): Handle id overflow.

    BasicBlock& exit = *insert_pt.InsertBefore(std::unique_ptr<BasicBlock>(

        new BasicBlock(std::unique_ptr<Instruction>(new Instruction(

            context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {})))));

    exit.SetParent(function);

    // Redirect in loop predecessors to |exit| block.

    for (uint32_t exit_pred_id : bb_pred) {

      if (loop_->IsInsideLoop(exit_pred_id)) {

        BasicBlock* pred_block = cfg.block(exit_pred_id);

        pred_block->ForEachSuccessorLabel([non_dedicate, &exit](uint32_t* id) {

          if (*id == non_dedicate->id()) *id = exit.id();

        });

        // Update the CFG.

        // |non_dedicate|'s predecessor list will be updated at the end of the

        // loop.

        cfg.RegisterBlock(pred_block);

      }

    }

    // Register the label to the def/use manager, requires for the phi patching.

    def_use_mgr->AnalyzeInstDefUse(exit.GetLabelInst());

    context_->set_instr_block(exit.GetLabelInst(), &exit);

    InstructionBuilder builder(context_, &exit, PreservedAnalyses);

    // Now jump from our dedicate basic block to the old exit.

    // We also reset the insert point so all instructions are inserted before

    // the branch.

    builder.SetInsertPoint(builder.AddBranch(non_dedicate->id()));

    non_dedicate->ForEachPhiInst(

        [&builder, &exit, def_use_mgr, this](Instruction* phi) {

          // New phi operands for this instruction.

          std::vector<uint32_t> new_phi_op;

          // Phi operands for the dedicated exit block.

          std::vector<uint32_t> exit_phi_op;

          for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) {

            uint32_t def_id = phi->GetSingleWordInOperand(i);

            uint32_t incoming_id = phi->GetSingleWordInOperand(i + 1);

            if (loop_->IsInsideLoop(incoming_id)) {

              exit_phi_op.push_back(def_id);

              exit_phi_op.push_back(incoming_id);

            } else {

              new_phi_op.push_back(def_id);

              new_phi_op.push_back(incoming_id);

            }

          }

          // Build the new phi instruction dedicated exit block.

          Instruction* exit_phi = builder.AddPhi(phi->type_id(), exit_phi_op);

          // Build the new incoming branch.

          new_phi_op.push_back(exit_phi->result_id());

          new_phi_op.push_back(exit.id());

          // Rewrite operands.

          uint32_t idx = 0;

          for (; idx < new_phi_op.size(); idx++)

            phi->SetInOperand(idx, {new_phi_op[idx]});

          // Remove extra operands, from last to first (more efficient).

          for (uint32_t j = phi->NumInOperands() - 1; j >= idx; j--)

            phi->RemoveInOperand(j);

          // Update the def/use manager for this |phi|.

          def_use_mgr->AnalyzeInstUse(phi);

        });

    // Update the CFG.

    cfg.RegisterBlock(&exit);

    cfg.RemoveNonExistingEdges(non_dedicate->id());

    new_loop_exits.insert(&exit);

    // If non_dedicate is in a loop, add the new dedicated exit in that loop.

    if (Loop* parent_loop = loop_desc[non_dedicate])

      parent_loop->AddBasicBlock(&exit);

  }

  if (new_loop_exits.size() == 1) {

    loop_->SetMergeBlock(*new_loop_exits.begin());

  }

  if (made_change) {

    context_->InvalidateAnalysesExceptFor(

        PreservedAnalyses | IRContext::kAnalysisCFG |

        IRContext::Analysis::kAnalysisLoopAnalysis);

  }

}

void LoopUtils::MakeLoopClosedSSA() {

  CreateLoopDedicatedExits();

  Function* function = loop_->GetHeaderBlock()->GetParent();

  CFG& cfg = *context_->cfg();

  DominatorTree& dom_tree =

      context_->GetDominatorAnalysis(function)->GetDomTree();

  std::unordered_set<BasicBlock*> exit_bb;

  {

    std::unordered_set<uint32_t> exit_bb_id;

    loop_->GetExitBlocks(&exit_bb_id);

    for (uint32_t bb_id : exit_bb_id) {

      exit_bb.insert(cfg.block(bb_id));

    }

  }

  LCSSARewriter lcssa_rewriter(context_, dom_tree, exit_bb,

                               loop_->GetMergeBlock());

  MakeSetClosedSSA(context_, function, loop_->GetBlocks(), exit_bb,

                   &lcssa_rewriter);

  // Make sure all defs post-dominated by the merge block have their last use no

  // further than the merge block.

  if (loop_->GetMergeBlock()) {

    std::unordered_set<uint32_t> merging_bb_id;

    loop_->GetMergingBlocks(&merging_bb_id);

    merging_bb_id.erase(loop_->GetMergeBlock()->id());

    // Reset the exit set, now only the merge block is the exit.

    exit_bb.clear();

    exit_bb.insert(loop_->GetMergeBlock());

    // LCSSARewriter is reusable here only because it forces the creation of a

    // phi instruction in the merge block.

    MakeSetClosedSSA(context_, function, merging_bb_id, exit_bb,

                     &lcssa_rewriter);

  }

  context_->InvalidateAnalysesExceptFor(

      IRContext::Analysis::kAnalysisCFG |

      IRContext::Analysis::kAnalysisDominatorAnalysis |

      IRContext::Analysis::kAnalysisLoopAnalysis);

}

Loop* LoopUtils::CloneLoop(LoopCloningResult* cloning_result) const {

  // Compute the structured order of the loop basic blocks and store it in the

  // vector ordered_loop_blocks.

  std::vector<BasicBlock*> ordered_loop_blocks;

  loop_->ComputeLoopStructuredOrder(&ordered_loop_blocks);

  // Clone the loop.

  return CloneLoop(cloning_result, ordered_loop_blocks);

}

Loop* LoopUtils::CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result) {

  // Clone the loop.

  Loop* new_loop = CloneLoop(cloning_result);

  // Create a new exit block/label for the new loop.

  // TODO(1841): Handle id overflow.

  std::unique_ptr<Instruction> new_label{new Instruction(

      context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {})};

  std::unique_ptr<BasicBlock> new_exit_bb{new BasicBlock(std::move(new_label))};

  new_exit_bb->SetParent(loop_->GetMergeBlock()->GetParent());

  // Create an unconditional branch to the header block.

  InstructionBuilder builder{context_, new_exit_bb.get()};

  builder.AddBranch(loop_->GetHeaderBlock()->id());

  // Save the ids of the new and old merge block.

  const uint32_t old_merge_block = loop_->GetMergeBlock()->id();

  const uint32_t new_merge_block = new_exit_bb->id();

  // Replace the uses of the old merge block in the new loop with the new merge

  // block.

  for (std::unique_ptr<BasicBlock>& basic_block : cloning_result->cloned_bb_) {

    for (Instruction& inst : *basic_block) {

      // For each operand in each instruction check if it is using the old merge

      // block and change it to be the new merge block.

      auto replace_merge_use = [old_merge_block,

                                new_merge_block](uint32_t* id) {

        if (*id == old_merge_block) *id = new_merge_block;

      };

      inst.ForEachInOperand(replace_merge_use);

    }

  }

  const uint32_t old_header = loop_->GetHeaderBlock()->id();

  const uint32_t new_header = new_loop->GetHeaderBlock()->id();

  analysis::DefUseManager* def_use = context_->get_def_use_mgr();

  def_use->ForEachUse(old_header,

                      [new_header, this](Instruction* inst, uint32_t operand) {

                        if (!this->loop_->IsInsideLoop(inst))

                          inst->SetOperand(operand, {new_header});

                      });

  // TODO(1841): Handle failure to create pre-header.

  def_use->ForEachUse(

      loop_->GetOrCreatePreHeaderBlock()->id(),

      [new_merge_block, this](Instruction* inst, uint32_t operand) {

        if (this->loop_->IsInsideLoop(inst))

          inst->SetOperand(operand, {new_merge_block});

      });

  new_loop->SetMergeBlock(new_exit_bb.get());

  new_loop->SetPreHeaderBlock(loop_->GetPreHeaderBlock());

  // Add the new block into the cloned instructions.

  cloning_result->cloned_bb_.push_back(std::move(new_exit_bb));

  return new_loop;

}

Loop* LoopUtils::CloneLoop(

    LoopCloningResult* cloning_result,

    const std::vector<BasicBlock*>& ordered_loop_blocks) const {

  analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr();

  std::unique_ptr<Loop> new_loop = MakeUnique<Loop>(context_);

  CFG& cfg = *context_->cfg();

  // Clone and place blocks in a SPIR-V compliant order (dominators first).

  for (BasicBlock* old_bb : ordered_loop_blocks) {

    // For each basic block in the loop, we clone it and register the mapping

    // between old and new ids.

    BasicBlock* new_bb = old_bb->Clone(context_);

    new_bb->SetParent(&function_);

    // TODO(1841): Handle id overflow.

    new_bb->GetLabelInst()->SetResultId(context_->TakeNextId());

    def_use_mgr->AnalyzeInstDef(new_bb->GetLabelInst());

    context_->set_instr_block(new_bb->GetLabelInst(), new_bb);

    cloning_result->cloned_bb_.emplace_back(new_bb);

    cloning_result->old_to_new_bb_[old_bb->id()] = new_bb;

    cloning_result->new_to_old_bb_[new_bb->id()] = old_bb;

    cloning_result->value_map_[old_bb->id()] = new_bb->id();

    if (loop_->IsInsideLoop(old_bb)) new_loop->AddBasicBlock(new_bb);

    for (auto new_inst = new_bb->begin(), old_inst = old_bb->begin();

         new_inst != new_bb->end(); ++new_inst, ++old_inst) {

      cloning_result->ptr_map_[&*new_inst] = &*old_inst;

      if (new_inst->HasResultId()) {

        // TODO(1841): Handle id overflow.

        new_inst->SetResultId(context_->TakeNextId());

        cloning_result->value_map_[old_inst->result_id()] =

            new_inst->result_id();

        // Only look at the defs for now, uses are not updated yet.

        def_use_mgr->AnalyzeInstDef(&*new_inst);

      }

    }

  }

  // All instructions (including all labels) have been cloned,

  // remap instruction operands id with the new ones.

  for (std::unique_ptr<BasicBlock>& bb_ref : cloning_result->cloned_bb_) {

    BasicBlock* bb = bb_ref.get();

    for (Instruction& insn : *bb) {

      insn.ForEachInId([cloning_result](uint32_t* old_id) {

        // If the operand is defined in the loop, remap the id.

        auto id_it = cloning_result->value_map_.find(*old_id);

        if (id_it != cloning_result->value_map_.end()) {

          *old_id = id_it->second;

        }

      });

      // Only look at what the instruction uses. All defs are register, so all

      // should be fine now.

      def_use_mgr->AnalyzeInstUse(&insn);

      context_->set_instr_block(&insn, bb);

    }

    cfg.RegisterBlock(bb);

  }

  PopulateLoopNest(new_loop.get(), *cloning_result);

  return new_loop.release();

}

void LoopUtils::PopulateLoopNest(

    Loop* new_loop, const LoopCloningResult& cloning_result) const {

  std::unordered_map<Loop*, Loop*> loop_mapping;

  loop_mapping[loop_] = new_loop;

  if (loop_->HasParent()) loop_->GetParent()->AddNestedLoop(new_loop);

  PopulateLoopDesc(new_loop, loop_, cloning_result);

  for (Loop& sub_loop :

       make_range(++TreeDFIterator<Loop>(loop_), TreeDFIterator<Loop>())) {

    Loop* cloned = new Loop(context_);

    if (Loop* parent = loop_mapping[sub_loop.GetParent()])

      parent->AddNestedLoop(cloned);

    loop_mapping[&sub_loop] = cloned;

    PopulateLoopDesc(cloned, &sub_loop, cloning_result);

  }

  loop_desc_->AddLoopNest(std::unique_ptr<Loop>(new_loop));

}

// Populates |new_loop| descriptor according to |old_loop|'s one.

void LoopUtils::PopulateLoopDesc(

    Loop* new_loop, Loop* old_loop,

    const LoopCloningResult& cloning_result) const {

  for (uint32_t bb_id : old_loop->GetBlocks()) {

    BasicBlock* bb = cloning_result.old_to_new_bb_.at(bb_id);

    new_loop->AddBasicBlock(bb);

  }

  new_loop->SetHeaderBlock(

      cloning_result.old_to_new_bb_.at(old_loop->GetHeaderBlock()->id()));

  if (old_loop->GetLatchBlock())

    new_loop->SetLatchBlock(

        cloning_result.old_to_new_bb_.at(old_loop->GetLatchBlock()->id()));

  if (old_loop->GetContinueBlock())

    new_loop->SetContinueBlock(

        cloning_result.old_to_new_bb_.at(old_loop->GetContinueBlock()->id()));

  if (old_loop->GetMergeBlock()) {

    auto it =

        cloning_result.old_to_new_bb_.find(old_loop->GetMergeBlock()->id());

    BasicBlock* bb = it != cloning_result.old_to_new_bb_.end()

                         ? it->second

                         : old_loop->GetMergeBlock();

    new_loop->SetMergeBlock(bb);

  }

  if (old_loop->GetPreHeaderBlock()) {

    auto it =

        cloning_result.old_to_new_bb_.find(old_loop->GetPreHeaderBlock()->id());

    if (it != cloning_result.old_to_new_bb_.end()) {

      new_loop->SetPreHeaderBlock(it->second);

    }

  }

}

// Class to gather some metrics about a region of interest.

void CodeMetrics::Analyze(const Loop& loop) {

  CFG& cfg = *loop.GetContext()->cfg();

  roi_size_ = 0;

  block_sizes_.clear();

  for (uint32_t id : loop.GetBlocks()) {

    const BasicBlock* bb = cfg.block(id);

    size_t bb_size = 0;

    bb->ForEachInst([&bb_size](const Instruction* insn) {

      if (insn->opcode() == spv::Op::OpLabel) return;

      if (insn->IsNop()) return;

      if (insn->opcode() == spv::Op::OpPhi) return;

      bb_size++;

    });

    block_sizes_[bb->id()] = bb_size;

    roi_size_ += bb_size;

  }

}

}  // namespace opt

}  // namespace spvtools