RegisterPasses.cpp

Go to the documentation of this file.

//===------ RegisterPasses.cpp - Add the Polly Passes to default passes  --===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file composes the individual LLVM-IR passes provided by Polly to a
// functional polyhedral optimizer. The polyhedral optimizer is automatically
// made available to LLVM based compilers by loading the Polly shared library
// into such a compiler.
//
// The Polly optimizer is made available by executing a static constructor that
// registers the individual Polly passes in the LLVM pass manager builder. The
// passes are registered such that the default behaviour of the compiler is not
// changed, but that the flag '-polly' provided at optimization level '-O3'
// enables additional polyhedral optimizations.
//===----------------------------------------------------------------------===//
 
#include "polly/RegisterPasses.h"
#include "polly/Canonicalization.h"
#include "polly/CodeGen/CodeGeneration.h"
#include "polly/CodeGen/IslAst.h"
#include "polly/CodePreparation.h"
#include "polly/DeLICM.h"
#include "polly/DeadCodeElimination.h"
#include "polly/DependenceInfo.h"
#include "polly/ForwardOpTree.h"
#include "polly/JSONExporter.h"
#include "polly/MaximalStaticExpansion.h"
#include "polly/Options.h"
#include "polly/Pass/PollyFunctionPass.h"
#include "polly/PruneUnprofitable.h"
#include "polly/ScheduleOptimizer.h"
#include "polly/ScopDetection.h"
#include "polly/ScopGraphPrinter.h"
#include "polly/ScopInfo.h"
#include "polly/ScopInliner.h"
#include "polly/Simplify.h"
#include "polly/Support/DumpFunctionPass.h"
#include "polly/Support/DumpModulePass.h"
#include "llvm/Analysis/CFGPrinter.h"
#include "llvm/Config/llvm-config.h" // for LLVM_VERSION_STRING
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Plugins/PassPlugin.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Transforms/IPO.h"
 
using namespace llvm;
using namespace polly;
 
namespace cl = llvm::cl;
using namespace polly;
 
using llvm::FunctionPassManager;
using llvm::OptimizationLevel;
using llvm::PassBuilder;
using llvm::PassInstrumentationCallbacks;
 
cl::OptionCategory PollyCategory("Polly Options",
                                 "Configure the polly loop optimizer");
 
namespace polly {
static cl::opt<bool>
    PollyEnabled("polly",
                 cl::desc("Enable the polly optimizer (with -O1, -O2 or -O3)"),
                 cl::cat(PollyCategory));
 
static cl::opt<bool> PollyDetectOnly(
    "polly-only-scop-detection",
    cl::desc("Only run scop detection, but no other optimizations"),
    cl::cat(PollyCategory));
 
enum PassPositionChoice { POSITION_EARLY, POSITION_BEFORE_VECTORIZER };
 
enum OptimizerChoice { OPTIMIZER_NONE, OPTIMIZER_ISL };
 
static cl::opt<PassPositionChoice> PassPosition(
    "polly-position", cl::desc("Where to run polly in the pass pipeline"),
    cl::values(clEnumValN(POSITION_EARLY, "early", "Before everything"),
               clEnumValN(POSITION_BEFORE_VECTORIZER, "before-vectorizer",
                          "Right before the vectorizer")),
    cl::Hidden, cl::init(POSITION_BEFORE_VECTORIZER), cl::cat(PollyCategory));
 
static cl::opt<OptimizerChoice>
    Optimizer("polly-optimizer", cl::desc("Select the scheduling optimizer"),
              cl::values(clEnumValN(OPTIMIZER_NONE, "none", "No optimizer"),
                         clEnumValN(OPTIMIZER_ISL, "isl",
                                    "The isl scheduling optimizer")),
              cl::Hidden, cl::init(OPTIMIZER_ISL), cl::cat(PollyCategory));
 
enum CodeGenChoice { CODEGEN_FULL, CODEGEN_AST, CODEGEN_NONE };
static cl::opt<CodeGenChoice> CodeGeneration(
    "polly-code-generation", cl::desc("How much code-generation to perform"),
    cl::values(clEnumValN(CODEGEN_FULL, "full", "AST and IR generation"),
               clEnumValN(CODEGEN_AST, "ast", "Only AST generation"),
               clEnumValN(CODEGEN_NONE, "none", "No code generation")),
    cl::Hidden, cl::init(CODEGEN_FULL), cl::cat(PollyCategory));
 
VectorizerChoice PollyVectorizerChoice;
 
static cl::opt<VectorizerChoice, true> Vectorizer(
    "polly-vectorizer", cl::desc("Select the vectorization strategy"),
    cl::values(
        clEnumValN(VECTORIZER_NONE, "none", "No Vectorization"),
        clEnumValN(
            VECTORIZER_STRIPMINE, "stripmine",
            "Strip-mine outer loops for the loop-vectorizer to trigger")),
    cl::location(PollyVectorizerChoice), cl::init(VECTORIZER_NONE),
    cl::cat(PollyCategory));
 
static cl::opt<bool> ImportJScop(
    "polly-import",
    cl::desc("Import the polyhedral description of the detected Scops"),
    cl::Hidden, cl::cat(PollyCategory));
 
static cl::opt<bool> FullyIndexedStaticExpansion(
    "polly-enable-mse",
    cl::desc("Fully expand the memory accesses of the detected Scops"),
    cl::Hidden, cl::cat(PollyCategory));
 
static cl::opt<bool> ExportJScop(
    "polly-export",
    cl::desc("Export the polyhedral description of the detected Scops"),
    cl::Hidden, cl::cat(PollyCategory));
 
static cl::opt<bool> DeadCodeElim("polly-run-dce",
                                  cl::desc("Run the dead code elimination"),
                                  cl::Hidden, cl::cat(PollyCategory));
 
static cl::opt<bool> PollyViewer(
    "polly-show",
    cl::desc("Highlight the code regions that will be optimized in a "
             "(CFG BBs and LLVM-IR instructions)"),
    cl::cat(PollyCategory));
 
static cl::opt<bool> PollyOnlyViewer(
    "polly-show-only",
    cl::desc("Highlight the code regions that will be optimized in "
             "a (CFG only BBs)"),
    cl::init(false), cl::cat(PollyCategory));
 
static cl::opt<bool>
    PollyPrinter("polly-dot", cl::desc("Enable the Polly DOT printer in -O3"),
                 cl::Hidden, cl::value_desc("Run the Polly DOT printer at -O3"),
                 cl::init(false), cl::cat(PollyCategory));
 
static cl::opt<bool> PollyOnlyPrinter(
    "polly-dot-only",
    cl::desc("Enable the Polly DOT printer in -O3 (no BB content)"), cl::Hidden,
    cl::value_desc("Run the Polly DOT printer at -O3 (no BB content"),
    cl::init(false), cl::cat(PollyCategory));
 
static cl::opt<bool>
    CFGPrinter("polly-view-cfg",
               cl::desc("Show the Polly CFG right after code generation"),
               cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
static cl::opt<bool>
    EnableForwardOpTree("polly-enable-optree",
                        cl::desc("Enable operand tree forwarding"), cl::Hidden,
                        cl::init(true), cl::cat(PollyCategory));
 
static cl::opt<bool>
    DumpBefore("polly-dump-before",
               cl::desc("Dump module before Polly transformations into a file "
                        "suffixed with \"-before\""),
               cl::init(false), cl::cat(PollyCategory));
 
static cl::list<std::string> DumpBeforeFile(
    "polly-dump-before-file",
    cl::desc("Dump module before Polly transformations to the given file"),
    cl::cat(PollyCategory));
 
static cl::opt<bool>
    DumpAfter("polly-dump-after",
              cl::desc("Dump module after Polly transformations into a file "
                       "suffixed with \"-after\""),
              cl::init(false), cl::cat(PollyCategory));
 
static cl::list<std::string> DumpAfterFile(
    "polly-dump-after-file",
    cl::desc("Dump module after Polly transformations to the given file"),
    cl::cat(PollyCategory));
 
static cl::opt<bool>
    EnableDeLICM("polly-enable-delicm",
                 cl::desc("Eliminate scalar loop carried dependences"),
                 cl::Hidden, cl::init(true), cl::cat(PollyCategory));
 
static cl::opt<bool>
    EnableSimplify("polly-enable-simplify",
                   cl::desc("Simplify SCoP after optimizations"),
                   cl::init(true), cl::cat(PollyCategory));
 
static cl::opt<bool> EnablePruneUnprofitable(
    "polly-enable-prune-unprofitable",
    cl::desc("Bail out on unprofitable SCoPs before rescheduling"), cl::Hidden,
    cl::init(true), cl::cat(PollyCategory));
 
static cl::opt<bool>
    PollyPrintDetect("polly-print-detect",
                     cl::desc("Polly - Print static control parts (SCoPs)"),
                     cl::cat(PollyCategory));
 
static cl::opt<bool>
    PollyPrintScops("polly-print-scops",
                    cl::desc("Print polyhedral description of all regions"),
                    cl::cat(PollyCategory));
 
static cl::opt<bool> PollyPrintDeps("polly-print-deps",
                                    cl::desc("Polly - Print dependences"),
                                    cl::cat(PollyCategory));
 
static bool shouldEnablePollyForOptimization() { return PollyEnabled; }
 
static bool shouldEnablePollyForDiagnostic() {
  // FIXME: PollyTrackFailures is user-controlled, should not be set
  // programmatically.
  if (PollyOnlyPrinter || PollyPrinter || PollyOnlyViewer || PollyViewer)
    PollyTrackFailures = true;
 
  return PollyOnlyPrinter || PollyPrinter || PollyOnlyViewer || PollyViewer ||
         ExportJScop;
}
 
/// Parser of parameters for LoopVectorize pass.
static llvm::Expected<PollyPassOptions> parsePollyOptions(StringRef Params,
                                                          bool IsCustom) {
  PassPhase PrevPhase = PassPhase::None;
 
  bool EnableDefaultOpts = !IsCustom;
  bool EnableEnd2End = !IsCustom;
  std::optional<bool>
      PassEnabled[static_cast<size_t>(PassPhase::PassPhaseLast) + 1];
  PassPhase StopAfter = PassPhase::None;
 
  // Passes enabled using command-line flags (can be overridden using
  // 'polly<no-pass>')
  if (PollyPrintDetect)
    PassEnabled[static_cast<size_t>(PassPhase::PrintDetect)] = true;
  if (PollyPrintScops)
    PassEnabled[static_cast<size_t>(PassPhase::PrintScopInfo)] = true;
  if (PollyPrintDeps)
    PassEnabled[static_cast<size_t>(PassPhase::PrintDependences)] = true;
 
  if (PollyViewer)
    PassEnabled[static_cast<size_t>(PassPhase::ViewScops)] = true;
  if (PollyOnlyViewer)
    PassEnabled[static_cast<size_t>(PassPhase::ViewScopsOnly)] = true;
  if (PollyPrinter)
    PassEnabled[static_cast<size_t>(PassPhase::DotScops)] = true;
  if (PollyOnlyPrinter)
    PassEnabled[static_cast<size_t>(PassPhase::DotScopsOnly)] = true;
  if (!EnableSimplify)
    PassEnabled[static_cast<size_t>(PassPhase::Simplify0)] = false;
  if (!EnableForwardOpTree)
    PassEnabled[static_cast<size_t>(PassPhase::Optree)] = false;
  if (!EnableDeLICM)
    PassEnabled[static_cast<size_t>(PassPhase::DeLICM)] = false;
  if (!EnableSimplify)
    PassEnabled[static_cast<size_t>(PassPhase::Simplify1)] = false;
  if (ImportJScop)
    PassEnabled[static_cast<size_t>(PassPhase::ImportJScop)] = true;
  if (DeadCodeElim)
    PassEnabled[static_cast<size_t>(PassPhase::DeadCodeElimination)] = true;
  if (FullyIndexedStaticExpansion)
    PassEnabled[static_cast<size_t>(PassPhase::MaximumStaticExtension)] = true;
  if (!EnablePruneUnprofitable)
    PassEnabled[static_cast<size_t>(PassPhase::PruneUnprofitable)] = false;
  switch (Optimizer) {
  case OPTIMIZER_NONE:
    // explicitly switched off
    PassEnabled[static_cast<size_t>(PassPhase::Optimization)] = false;
    break;
  case OPTIMIZER_ISL:
    // default: enabled
    break;
  }
  if (ExportJScop)
    PassEnabled[static_cast<size_t>(PassPhase::ExportJScop)] = true;
  switch (CodeGeneration) {
  case CODEGEN_AST:
    PassEnabled[static_cast<size_t>(PassPhase::AstGen)] = true;
    PassEnabled[static_cast<size_t>(PassPhase::CodeGen)] = false;
    break;
  case CODEGEN_FULL:
    // default: ast and codegen enabled
    break;
  case CODEGEN_NONE:
    PassEnabled[static_cast<size_t>(PassPhase::AstGen)] = false;
    PassEnabled[static_cast<size_t>(PassPhase::CodeGen)] = false;
    break;
  }
 
  while (!Params.empty()) {
    StringRef Param;
    std::tie(Param, Params) = Params.split(';');
    auto [ParamName, ParamVal] = Param.split('=');
 
    if (ParamName == "stopafter") {
      StopAfter = parsePhase(ParamVal);
      if (StopAfter == PassPhase::None)
        return make_error<StringError>(
            formatv("invalid stopafter parameter value '{0}'", ParamVal).str(),
            inconvertibleErrorCode());
      continue;
    }
 
    if (!ParamVal.empty())
      return make_error<StringError>(
          formatv("parameter '{0}' does not take value", ParamName).str(),
          inconvertibleErrorCode());
 
    bool Enabled = true;
    if (ParamName.starts_with("no-")) {
      Enabled = false;
      ParamName = ParamName.drop_front(3);
    }
 
    if (ParamName == "default-opts") {
      EnableDefaultOpts = Enabled;
      continue;
    }
 
    if (ParamName == "end2end") {
      EnableEnd2End = Enabled;
      continue;
    }
 
    PassPhase Phase;
 
    // Shortcut for both simplifys at the same time
    if (ParamName == "simplify") {
      PassEnabled[static_cast<size_t>(PassPhase::Simplify0)] = Enabled;
      PassEnabled[static_cast<size_t>(PassPhase::Simplify1)] = Enabled;
      Phase = PassPhase::Simplify0;
    } else {
      Phase = parsePhase(ParamName);
      if (Phase == PassPhase::None)
        return make_error<StringError>(
            formatv("invalid Polly parameter/phase name '{0}'", ParamName)
                .str(),
            inconvertibleErrorCode());
 
      if (PrevPhase >= Phase)
        return make_error<StringError>(
            formatv("phases must not be repeated and enumerated in-order: "
                    "'{0}' listed before '{1}'",
                    getPhaseName(PrevPhase), getPhaseName(Phase))
                .str(),
            inconvertibleErrorCode());
 
      PassEnabled[static_cast<size_t>(Phase)] = Enabled;
    }
    PrevPhase = Phase;
  }
 
  PollyPassOptions Opts;
  Opts.ViewAll = ViewAll;
  Opts.ViewFilter = ViewFilter;
  Opts.PrintDepsAnalysisLevel = OptAnalysisLevel;
 
  // Implicitly enable dependent phases first. May be overriden explicitly
  // on/off later.
  for (PassPhase P : llvm::enum_seq_inclusive(PassPhase::PassPhaseFirst,
                                              PassPhase::PassPhaseLast)) {
    bool Enabled = PassEnabled[static_cast<size_t>(P)].value_or(false);
    if (!Enabled)
      continue;
 
    if (static_cast<size_t>(PassPhase::Detection) < static_cast<size_t>(P))
      Opts.setPhaseEnabled(PassPhase::Detection);
 
    if (static_cast<size_t>(PassPhase::ScopInfo) < static_cast<size_t>(P))
      Opts.setPhaseEnabled(PassPhase::ScopInfo);
 
    if (dependsOnDependenceInfo(P))
      Opts.setPhaseEnabled(PassPhase::Dependences);
 
    if (static_cast<size_t>(PassPhase::AstGen) < static_cast<size_t>(P))
      Opts.setPhaseEnabled(PassPhase::AstGen);
  }
 
  if (EnableEnd2End)
    Opts.enableEnd2End();
 
  if (EnableDefaultOpts)
    Opts.enableDefaultOpts();
 
  for (PassPhase P : llvm::enum_seq_inclusive(PassPhase::PassPhaseFirst,
                                              PassPhase::PassPhaseLast)) {
    std::optional<bool> Enabled = PassEnabled[static_cast<size_t>(P)];
 
    // Apply only if set explicitly.
    if (Enabled.has_value())
      Opts.setPhaseEnabled(P, *Enabled);
  }
 
  if (StopAfter != PassPhase::None)
    Opts.disableAfter(StopAfter);
 
  if (Error CheckResult = Opts.checkConsistency())
    return CheckResult;
 
  return Opts;
}
 
static llvm::Expected<PollyPassOptions>
parsePollyDefaultOptions(StringRef Params) {
  return parsePollyOptions(Params, false);
}
 
static llvm::Expected<PollyPassOptions>
parsePollyCustomOptions(StringRef Params) {
  return parsePollyOptions(Params, true);
}
 
/// Register Polly passes such that they form a polyhedral optimizer.
///
/// The individual Polly passes are registered in the pass manager such that
/// they form a full polyhedral optimizer. The flow of the optimizer starts with
/// a set of preparing transformations that canonicalize the LLVM-IR such that
/// the LLVM-IR is easier for us to understand and to optimizes. On the
/// canonicalized LLVM-IR we first run the ScopDetection pass, which detects
/// static control flow regions. Those regions are then translated by the
/// ScopInfo pass into a polyhedral representation. As a next step, a scheduling
/// optimizer is run on the polyhedral representation and finally the optimized
/// polyhedral representation is code generated back to LLVM-IR.
///
/// Besides this core functionality, we optionally schedule passes that provide
/// a graphical view of the scops (Polly[Only]Viewer, Polly[Only]Printer), that
/// allow the export/import of the polyhedral representation
/// (JSCON[Exporter|Importer]) or that show the cfg after code generation.
///
/// For certain parts of the Polly optimizer, several alternatives are provided:
///
/// As scheduling optimizer we support the isl scheduling optimizer
/// (http://freecode.com/projects/isl).
/// It is also possible to run Polly with no optimizer. This mode is mainly
/// provided to analyze the run and compile time changes caused by the
/// scheduling optimizer.
///
/// Polly supports the isl internal code generator.
 
/// Add the pass sequence required for Polly to the New Pass Manager.
///
/// @param PM           The pass manager itself.
/// @param Level        The optimization level. Used for the cleanup of Polly's
///                     output.
/// @param EnableForOpt Whether to add Polly IR transformations. If False, only
///                     the analysis passes are added, skipping Polly itself.
///                     The IR may still be modified.
static void buildCommonPollyPipeline(FunctionPassManager &PM,
                                     OptimizationLevel Level,
                                     IntrusiveRefCntPtr<vfs::FileSystem> FS,
                                     bool EnableForOpt) {
  PassBuilder PB(
      /*TM=*/nullptr,
      /*PipelineTuningOptions=*/{},
      /*PGOOpt=*/{},
      /*PIC=*/nullptr, std::move(FS));
 
  ExitOnError Err("Inconsistent Polly configuration: ");
  PollyPassOptions &&Opts =
      Err(parsePollyOptions(StringRef(), /*IsCustom=*/false));
  PM.addPass(PollyFunctionPass(Opts));
 
  PM.addPass(PB.buildFunctionSimplificationPipeline(
      Level, llvm::ThinOrFullLTOPhase::None)); // Cleanup
 
  if (CFGPrinter)
    PM.addPass(llvm::CFGPrinterPass());
}
 
static void buildEarlyPollyPipeline(llvm::ModulePassManager &MPM,
                                    llvm::OptimizationLevel Level,
                                    IntrusiveRefCntPtr<vfs::FileSystem> FS) {
  bool EnableForOpt =
      shouldEnablePollyForOptimization() && Level.isOptimizingForSpeed();
  if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
    return;
 
  FunctionPassManager FPM = buildCanonicalicationPassesForNPM(MPM, Level);
 
  if (DumpBefore || !DumpBeforeFile.empty()) {
    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
    if (DumpBefore)
      MPM.addPass(DumpModulePass("-before", true));
    for (auto &Filename : DumpBeforeFile)
      MPM.addPass(DumpModulePass(Filename, false));
 
    FPM = FunctionPassManager();
  }
 
  buildCommonPollyPipeline(FPM, Level, std::move(FS), EnableForOpt);
  MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
  if (DumpAfter)
    MPM.addPass(DumpModulePass("-after", true));
  for (auto &Filename : DumpAfterFile)
    MPM.addPass(DumpModulePass(Filename, false));
}
 
static void buildLatePollyPipeline(FunctionPassManager &PM,
                                   llvm::OptimizationLevel Level,
                                   IntrusiveRefCntPtr<vfs::FileSystem> FS) {
  bool EnableForOpt =
      shouldEnablePollyForOptimization() && Level.isOptimizingForSpeed();
  if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
    return;
 
  if (DumpBefore)
    PM.addPass(DumpFunctionPass("-before"));
  if (!DumpBeforeFile.empty())
    llvm::report_fatal_error(
        "Option -polly-dump-before-file at -polly-position=late "
        "not supported with NPM",
        false);
 
  buildCommonPollyPipeline(PM, Level, std::move(FS), EnableForOpt);
 
  if (DumpAfter)
    PM.addPass(DumpFunctionPass("-after"));
  if (!DumpAfterFile.empty())
    llvm::report_fatal_error(
        "Option -polly-dump-after-file at -polly-position=late "
        "not supported with NPM",
        false);
}
 
static llvm::Expected<std::monostate> parseNoOptions(StringRef Params) {
  if (!Params.empty())
    return make_error<StringError>(
        formatv("'{0}' passed to pass that does not take any options", Params)
            .str(),
        inconvertibleErrorCode());
 
  return std::monostate{};
}
 
static llvm::Expected<bool>
parseCGPipeline(StringRef Name, llvm::CGSCCPassManager &CGPM,
                PassInstrumentationCallbacks *PIC,
                ArrayRef<PassBuilder::PipelineElement> Pipeline,
                IntrusiveRefCntPtr<vfs::FileSystem> FS) {
#define CGSCC_PASS(NAME, CREATE_PASS, PARSER)                                  \
  if (PassBuilder::checkParametrizedPassName(Name, NAME)) {                    \
    auto Params = PassBuilder::parsePassParameters(PARSER, Name, NAME);        \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    CGPM.addPass(CREATE_PASS);                                                 \
    return true;                                                               \
  }
#include "PollyPasses.def"
 
  return false;
}
 
static llvm::Expected<bool>
parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
                      PassInstrumentationCallbacks *PIC,
                      ArrayRef<PassBuilder::PipelineElement> Pipeline) {
 
#define FUNCTION_PASS(NAME, CREATE_PASS, PARSER)                               \
  if (PassBuilder::checkParametrizedPassName(Name, NAME)) {                    \
    auto ExpectedOpts = PassBuilder::parsePassParameters(PARSER, Name, NAME);  \
    if (!ExpectedOpts)                                                         \
      return ExpectedOpts.takeError();                                         \
    auto &&Opts = *ExpectedOpts;                                               \
    (void)Opts;                                                                \
    FPM.addPass(CREATE_PASS);                                                  \
    return true;                                                               \
  }
 
#include "PollyPasses.def"
  return false;
}
 
static llvm::Expected<bool>
parseModulePipeline(StringRef Name, llvm::ModulePassManager &MPM,
                    PassInstrumentationCallbacks *PIC,
                    ArrayRef<PassBuilder::PipelineElement> Pipeline) {
#define MODULE_PASS(NAME, CREATE_PASS, PARSER)                                 \
  if (PassBuilder::checkParametrizedPassName(Name, NAME)) {                    \
    auto ExpectedOpts = PassBuilder::parsePassParameters(PARSER, Name, NAME);  \
    if (!ExpectedOpts)                                                         \
      return ExpectedOpts.takeError();                                         \
    auto &&Opts = *ExpectedOpts;                                               \
    (void)Opts;                                                                \
    MPM.addPass(CREATE_PASS);                                                  \
    return true;                                                               \
  }
 
#include "PollyPasses.def"
 
  return false;
}
 
/// Register Polly to be available as an optimizer
///
///
/// We can currently run Polly at two different points int the pass manager.
/// a) very early, b) right before the vectorizer.
///
/// The default is currently a), to register Polly such that it runs as early as
/// possible. This has several implications:
///
///   1) We need to schedule more canonicalization passes
///
///   As nothing is run before Polly, it is necessary to run a set of preparing
///   transformations before Polly to canonicalize the LLVM-IR and to allow
///   Polly to detect and understand the code.
///
///   2) We get the full -O3 optimization sequence after Polly
///
///   The LLVM-IR that is generated by Polly has been optimized on a high level,
///   but it may be rather inefficient on the lower/scalar level. By scheduling
///   Polly before all other passes, we have the full sequence of -O3
///   optimizations behind us, such that inefficiencies on the low level can
///   be optimized away.
///
/// We are currently evaluating the benefit or running Polly at b). b) is nice
/// as everything is fully inlined and canonicalized, but we need to be able to
/// handle LICMed code to make it useful.
void registerPollyPasses(PassBuilder &PB) {
  PassInstrumentationCallbacks *PIC = PB.getPassInstrumentationCallbacks();
  IntrusiveRefCntPtr<vfs::FileSystem> FS = PB.getVirtualFileSystemPtr();
 
#define MODULE_PASS(NAME, CREATE_PASS, PARSER)                                 \
  {                                                                            \
    std::remove_reference_t<decltype(*PARSER(StringRef()))> Opts;              \
    (void)Opts;                                                                \
    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);              \
  }
#define CGSCC_PASS(NAME, CREATE_PASS, PARSER)                                  \
  {                                                                            \
    std::remove_reference_t<decltype(*PARSER(StringRef()))> Opts;              \
    (void)Opts;                                                                \
    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);              \
  }
#define FUNCTION_PASS(NAME, CREATE_PASS, PARSER)                               \
  {                                                                            \
    std::remove_reference_t<decltype(*PARSER(StringRef()))> Opts;              \
    (void)Opts;                                                                \
    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);              \
  }
#include "PollyPasses.def"
 
  PB.registerPipelineParsingCallback(
      [PIC](StringRef Name, FunctionPassManager &FPM,
            ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
        ExitOnError Err("Unable to parse Polly module pass: ");
        return Err(parseFunctionPipeline(Name, FPM, PIC, Pipeline));
      });
  PB.registerPipelineParsingCallback(
      [PIC, FS](StringRef Name, CGSCCPassManager &CGPM,
                ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
        ExitOnError Err("Unable to parse Polly call graph pass: ");
        return Err(parseCGPipeline(Name, CGPM, PIC, Pipeline, FS));
      });
  PB.registerPipelineParsingCallback(
      [PIC](StringRef Name, ModulePassManager &MPM,
            ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
        ExitOnError Err("Unable to parse Polly module pass: ");
        return Err(parseModulePipeline(Name, MPM, PIC, Pipeline));
      });
 
  switch (PassPosition) {
  case POSITION_EARLY:
    PB.registerPipelineStartEPCallback(
        [FS](ModulePassManager &MPM, OptimizationLevel Level) {
          buildEarlyPollyPipeline(MPM, Level, FS);
        });
    break;
  case POSITION_BEFORE_VECTORIZER:
    PB.registerVectorizerStartEPCallback(
        [FS](FunctionPassManager &FPM, OptimizationLevel Level) {
          buildLatePollyPipeline(FPM, Level, FS);
        });
    break;
  }
}
} // namespace polly
 
llvm::PassPluginLibraryInfo getPollyPluginInfo() {
  return {LLVM_PLUGIN_API_VERSION, "Polly", LLVM_VERSION_STRING,
          polly::registerPollyPasses};
}