Method ProcessFunction

source/opt/loop_peeling.cpp:653–710

}

Pass::Status LoopPeelingPass::ProcessFunction(Function* f) {
  bool modified = false;
  LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(f);

  std::vector<Loop*> to_process_loop;
  to_process_loop.reserve(loop_descriptor.NumLoops());
  for (Loop& l : loop_descriptor) {
    to_process_loop.push_back(&l);
  }

  ScalarEvolutionAnalysis scev_analysis(context());

  for (Loop* loop : to_process_loop) {
    CodeMetrics loop_size;
    loop_size.Analyze(*loop);

    auto try_peel = [&loop_size, &modified, this](
                        Loop* loop_to_peel) -> std::pair<Pass::Status, Loop*> {
      if (!loop_to_peel->IsLCSSA()) {
        if (!LoopUtils(context(), loop_to_peel).MakeLoopClosedSSA()) {
          return {Pass::Status::Failure, nullptr};
        }
      }

      Pass::Status status;
      Loop* still_peelable_loop;
      std::tie(status, still_peelable_loop) =
          ProcessLoop(loop_to_peel, &loop_size);

      if (status == Pass::Status::SuccessWithChange) {
        modified = true;
      }

      return {status, still_peelable_loop};
    };

    Pass::Status status;
    Loop* still_peelable_loop;
    std::tie(status, still_peelable_loop) = try_peel(loop);

    if (status == Pass::Status::Failure) {
      return Pass::Status::Failure;
    }

    // The pass is working out the maximum factor by which a loop can be peeled.
    // If the loop can potentially be peeled again, then there is only one
    // possible direction, so only one call is still needed.
    if (still_peelable_loop) {
      std::tie(status, still_peelable_loop) = try_peel(still_peelable_loop);
      if (status == Pass::Status::Failure) {
        return Pass::Status::Failure;
      }
    }
  }

  return modified ? Pass::Status::SuccessWithChange
                  : Pass::Status::SuccessWithoutChange;
}