[Polly][Unfinished][NFC] Restructure the command line options

[jdoerfert]

Summary

This is an unfinished patch to show the direction I try to go,
discussion are welcome.

The changes include:
  - Unify the internal option names:      PollyXxxxxYyyyZzzz
  - Unify the command line options names: -polly-Xxxx-Yyyy-Zzzz
  - Collect all command line options in Optiohs.{h,cpp}
  - Expose all options to other LLVM projects (or passes)
  - Categorize and document the options (all in Option.h)

[jdoerfert]

lib/CodeGen/BlockGenerators.cpp

40

Can somebody explain this option to me?

[simbuerg]

This is exactly what I feared.
I'm not sure if I'm the only one, but I really like the definition of the command-line options where they matter: In the file where they influence something. Why would we want to extract the definitions too? Isn't it sufficient to provide the Options.h header and be done with it (+unify the naming)?

Furthermore this adds maintenance overhead: The description the end-user gets should be enough to understand what the option does. So reading the cl::desc field of a definition should suffice to understand what the option will do. Now you have to keep the comment synchronized to the description (nobody will do that ;-)).

Maybe I'm old, but the only benefits I see here are the external linkage via Options.h and the consistent naming, no need for relocating the definitions too.

[jdoerfert]

In D5762#5, @simbuerg wrote:

Maybe I'm old, but the only benefits I see here are the external linkage via Options.h and the consistent naming, no need for relocating the definitions too.

I find myself more often than I like looking for command line options to control something. I want to know the command line name and the default value, however that's not that easy:

Do you know where SCEVCodegen is declared, how to enable OpenMP code generation or what option will disable runtime alias checks?

These are some of the options that have a non-local effect; thus you might not find in the command line option declaration in the files you'd expect.

If you are interested in the effect of the internal command line option variable you will still see the same as before if you only open your pass. If the option variables are namend properly you don't need to look at the command line option declaration to understand the code.

if (PollyEnableTiling)
  XXX

I do not insist on this change, if others have the same objections or you feel realy strongly about this I don't mind take that part back. But in general I still think it will clean up Polly and help us.

[btw. SCEVCodegen -> BlockGenerators.cpp, OpenMP -> CodeGeneration.cpp, RTCs -> ScopDetection.cpp]

[simbuerg]

Alright, I got a closer second look and now I think it actually looks nicer than before ;-). Thanks for explaining.

[jdoerfert]

I'll wait for a thrid opinion before I proceed here.

[dpeixott]

This looks like a nice cleanup to me. I think centralizing the available options for polly makes sense. The major downside in my opinion is that we now have a bunch of global variables. Previously you could look at a command line option that is declared static (without external storage) and know it is only used in that file. Now we are exposing these all as global variables.

As for the implementation, maybe we should consider using an opt or options namespace inside polly for all the command line options. This would make it clear when reading the code that we are referencing a command line option and we know where to look for the definition if needed.

Something like

namespace polly {
namespace opt {
  bool DisablTiling
}}

...
if (opt::DisableTiling) 
 ...

You are already essentially namespacing the variables by adding a Polly prefix.

We should also be aware of how llvm is changing command line options to move away from using static initializers: http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-August/075886.html. I'm not sure exactly what conclusion they came to, but we don't want to come with a design that will be incompatible with where the llvm community is headed.

[jdoerfert]

In D5762#9, @dpeixott wrote:

This looks like a nice cleanup to me. I think centralizing the available options for polly makes sense. The major downside in my opinion is that we now have a bunch of global variables. Previously you could look at a command line option that is declared static (without external storage) and know it is only used in that file. Now we are exposing these all as global variables.

That is actually one of the reasons I came up with this patch. I want the options to be available to other LLVM pasess/projects, thus I have to expose them somehow. While I agree that global variables are not the best solution to this problem it is/was the easiest solution to allow me to configure Polly from within another project. Do you think we should wait/look for a different solution without the globals?

As for the implementation, maybe we should consider using an opt or options namespace inside polly for all the command line options. This would make it clear when reading the code that we are referencing a command line option and we know where to look for the definition if needed.

Nice idea, I will do this.

You are already essentially namespacing the variables by adding a Polly prefix.

Indeed. Should I replace or add the opt namespace (what do you think?)

We should also be aware of how llvm is changing command line options to move away from using static initializers: http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-August/075886.html. I'm not sure exactly what conclusion they came to, but we don't want to come with a design that will be incompatible with where the llvm community is headed.

I think this is not a blocking concern right now. As soon as they come to a conclusion we will adobpt it, however if we change 10 global variables to createXXXPass arguments then or 30 shouldn't make much of a difference. In the meantime we get closer to an organized and document way of handling command line options. We can reuse the documentation and structure also for the proposed new interface:

From:
  /// @brief Scheduler Options
  ///
  ///{
  
  /// @brief LaLaLa
  bool opt::PollyOption0;

  ///}

To:
  /// @brief Create Scheduling related passes
  ///
  ///{
  
  /// @brief XXX
  ///
  /// @bparam LaLaLa
  createXXXXPass(bool opt::PollyOption0);

  ///}

Do you think the discussion on the list blocks a refactoring like this?

[I talked to Tobias; he will be fine with any decision we come up with in our discussion here]

[dpeixott]

In D5762#10, @jdoerfert wrote:

In D5762#9, @dpeixott wrote:

This looks like a nice cleanup to me. I think centralizing the available options for polly makes sense. The major downside in my opinion is that we now have a bunch of global variables. Previously you could look at a command line option that is declared static (without external storage) and know it is only used in that file. Now we are exposing these all as global variables.

That is actually one of the reasons I came up with this patch. I want the options to be available to other LLVM pasess/projects, thus I have to expose them somehow. While I agree that global variables are not the best solution to this problem it is/was the easiest solution to allow me to configure Polly from within another project. Do you think we should wait/look for a different solution without the globals?

I am ok to go with your current patch. We are already using globals in Polly, so this patch is effectively cleaning up and centralizing existing behavior. I don't see global variables used like this anywhere else in LLVM, so it is concerning from that perspective, but I don't think it needs to hold up this patch.

As for the implementation, maybe we should consider using an opt or options namespace inside polly for all the command line options. This would make it clear when reading the code that we are referencing a command line option and we know where to look for the definition if needed.

Nice idea, I will do this.

Cool. I would suggest either using opt which is nice and short, but also make me think "optimization", or knob for the namespace.

You are already essentially namespacing the variables by adding a Polly prefix.

Indeed. Should I replace or add the opt namespace (what do you think?)

I would drop the Polly prefix. From within Polly namespace it will look fine to write opt::Foo instead of opt::PollyFoo, and from outside people can use polly::opt::Foo, which I think looks nicer than polly::opt::PollyFoo.

We should also be aware of how llvm is changing command line options to move away from using static initializers: http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-August/075886.html. I'm not sure exactly what conclusion they came to, but we don't want to come with a design that will be incompatible with where the llvm community is headed.

I think this is not a blocking concern right now. As soon as they come to a conclusion we will adobpt it, however if we change 10 global variables to createXXXPass arguments then or 30 shouldn't make much of a difference. In the meantime we get closer to an organized and document way of handling command line options. We can reuse the documentation and structure also for the proposed new interface:

From:
  /// @brief Scheduler Options
  ///
  ///{
  
  /// @brief LaLaLa
  bool opt::PollyOption0;

  ///}

To:
  /// @brief Create Scheduling related passes
  ///
  ///{
  
  /// @brief XXX
  ///
  /// @bparam LaLaLa
  createXXXXPass(bool opt::PollyOption0);

  ///}

Do you think the discussion on the list blocks a refactoring like this?

No I don't think it should block the refactoring. I just brought it up in case you had some good thoughts about it. Hopefully we will be able to adapt to the change easier by having a centralized location for argument handling.

[I talked to Tobias; he will be fine with any decision we come up with in our discussion here]

Ok, sounds good.

[grosser]

I never was excited about this change, but was OK with it to go in assuming there was agreement that the command line refactoring aimed for is preferable. This agreement had been reached, but for unknown reasons the patch was never completed. As it is now pretty old, we should probably start a new discussion in case anybody is interested in such a change.

I drop from the review to clean my queue.

include/polly/CodeGen/BlockGenerators.h

 
 namespace llvm {
 class Pass;
 class Region;
 class ScalarEvolution;
 }
 
 namespace polly {
-extern bool SCEVCodegen;
-
 using namespace llvm;
 class ScopStmt;
 class MemoryAccess;
 class IslExprBuilder;
 
 typedef DenseMap<const Value *, Value *> ValueMapT;
 typedef std::vector<ValueMapT> VectorValueMapT;
 

include/polly/CodeGen/CodeGeneration.h

 #define POLLY_CODEGENERATION_H
 
 #include "polly/Config/config.h"
 
 #include "isl/set.h"
 #include "isl/map.h"
 
 namespace polly {
-enum VectorizerChoice {
-  VECTORIZER_NONE,
-  VECTORIZER_POLLY,
-  VECTORIZER_UNROLL_ONLY,
-  VECTORIZER_FIRST_NEED_GROUPED_UNROLL = VECTORIZER_UNROLL_ONLY,
-  VECTORIZER_BB
-};
-extern VectorizerChoice PollyVectorizerChoice;
-
-enum CodeGenChoice {
-#ifdef CLOOG_FOUND
-  CODEGEN_CLOOG,
-#endif
-  CODEGEN_ISL,
-  CODEGEN_NONE
-};
-extern CodeGenChoice PollyCodeGenChoice;
-
-/// @brief Flag to turn on/off annotation of alias scopes.
-extern bool PollyAnnotateAliasScopes;
 
 static inline int getNumberOfIterations(__isl_take isl_set *Domain) {
   int Dim = isl_set_dim(Domain, isl_dim_set);
 
   // Calculate a map similar to the identity map, but with the last input
   // and output dimension not related.
   //  [i0, i1, i2, i3] -> [i0, i1, i2, o0]
   isl_space *Space = isl_set_get_space(Domain);

include/polly/Options.h

 //===--------------- polly/Options.h - The Polly option category *- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// Introduce an option category for Polly.
+// Introduce an option category for Polly and expose all options to other
+// passes or projects. The default values can be found in Options.cpp.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_OPTIONS_H
 #define POLLY_OPTIONS_H
 
 #include "llvm/Support/CommandLine.h"
 
 extern llvm::cl::OptionCategory PollyCategory;
+
+namespace polly {
+
+/// @name SCoP detection options
+///
+///{
+
+/// @brief Use ScalarEvolution to synthesize values instead of copying them.
+///
+/// @note This will lift the restriction on canonical induction variables.
+extern bool PollySCEVCodegen;
+
+/// @brief Flag to enable runtime alias checks (isl backend only).
+///
+/// @note This will lift the restriction on non-aliasing pointers.
+extern bool PollyUseRuntimeAliasChecks;
+
+/// @brief Flag to check for SCoPs in regions without loops.
+extern bool PollyDetectScopsInRegionsWithoutLoops;
+
+/// @brief Flag to check for SCoPs in functions without loops.
+extern bool PollyDetectScopsInFunctionsWithoutLoops;
+
+/// @brief Flag to enable over approximation of non-affine memory accesses.
+extern bool PollyAllowNonAffine;
+
+/// @brief Flag to enable tracking of reasons for invalid SCoPs.
+extern bool PollyTrackFailures;
+
+/// @brief Flag to enable delinearization of memory accesses.
+extern bool PollyDelinearize;
+
+/// @brief Flag to ignore possible alising (no runtime checks!).
+extern bool PollyIgnoreAliasing;
+
+/// @brief Flag to enable verification of the SCoPs after optimization.
+extern bool PollyDetectionVerify;
+
+/// @brief Flag to enable additional information about the detected SCoPs.
+extern bool PollyDetectionReport;
+
+/// @brief Flag to force detection to keep going even if a region is not a SCoP.
+extern bool PollyKeepGoing;
+
+/// @brief Flag to disable multiplicative reductions.
+extern bool PollyDisableMultiplicativeReductions;
+
+/// @brief Limit for the maximal number of parameters involved in an RTC access.
+extern unsigned PollyRunTimeChecksMaxParameters;
+
+/// @brief Limit detection to regions with a name containing this string.
+extern std::string PollyOnlyRegion;
+
+/// @brief Limit detection to functions with a name containing this string.
+extern std::string PollyOnlyFunction;
+
+///}
+
+/// @name Scheduling options
+///
+/// TODO: Expose more options to other LLVM passes.
+///
+///{
+
+/// @brief Limit on isl operations before Polly stops the dependence analysis.
+extern unsigned PollyDependenceComputeOut;
+
+/// @brief Flag to decide whether or not Polly will apply tiling.
+extern bool PollyDisableTiling;
+
+/// @brief Flag to disable legality check for imported schedules.
+extern bool PollyDependenceNoLegalityCheck;
+
+/// @brief The possible choices Polly has to generate dependence information.
+enum AnalysisType {
+  VALUE_BASED_ANALYSIS, ///< Exact dependences without transitive dependences
+  MEMORY_BASED_ANALYSIS ///< Overapproximation of dependences
+};
+
+/// @brief The kind of analysis polly will use to compute dependences.
+extern AnalysisType PollyDependenceAnalysisType;
+
+///}
+
+/// @name Code generation options
+///
+/// TODO: Some of the options are not explained very well.
+///
+///{
+
+/// @brief Assume aligned memory accesses.
+///
+/// @TODO This options seems depraced and if not badly named.
+extern bool PollyAssumeAligned;
+
+/// @brief Use Polly to add alias scopes to new generated SCoPs.
+extern bool PollyAnnotateAliasScopes;
+
+/// @brief The possible choices Polly has to generate "vectorized" code.
+enum VectorizerChoice {
+  VECTORIZER_NONE,        ///< Generate scalar code
+  VECTORIZER_POLLY,       ///< Generate vectorized code
+  VECTORIZER_UNROLL_ONLY, ///< Only unroll vectorizable loops
+  VECTORIZER_BB           ///< Unroll vectorizable loops + BB Vectorizer
+};
+
+/// @brief The kind of vectorization Polly will use.
+extern VectorizerChoice PollyVectorizerChoice;
+
+/// @brief The possible choices Polly has to generate LLVM-IR.
+enum CodeGenChoice {
+#ifdef CLOOG_FOUND
+  CODEGEN_CLOOG, ///< Use the cloog backend (only if build with cloog)
+#endif
+  CODEGEN_ISL, ///< Use the isl backend
+  CODEGEN_NONE ///< Do not generate LLVM-IR (analyze only)
+};
+
+/// @brief The kind of code generation Polly will use
+extern CodeGenChoice PollyCodeGenChoice;
+
+///}
+}
 #endif

include/polly/ScheduleOptimizer.h

-//===------ polly/ScheduleOptimizer.h - The Schedule Optimizer *- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef POLLY_SCHEDULE_OPTIMIZER_H
-#define POLLY_SCHEDULE_OPTIMIZER_H
-
-namespace polly {
-extern bool DisablePollyTiling;
-}
-
-#endif

include/polly/ScopDetection.h

 };
 
 typedef std::map<const Instruction *, MemAcc *> MapInsnToMemAcc;
 typedef std::pair<const Instruction *, const SCEV *> PairInstSCEV;
 typedef std::vector<PairInstSCEV> AFs;
 typedef std::map<const SCEVUnknown *, AFs> BaseToAFs;
 typedef std::map<const SCEVUnknown *, const SCEV *> BaseToElSize;
 
-extern bool PollyTrackFailures;
-extern bool PollyDelinearize;
-extern bool PollyUseRuntimeAliasChecks;
-
 /// @brief A function attribute which will cause Polly to skip the function
 extern llvm::StringRef PollySkipFnAttr;
 
 //===----------------------------------------------------------------------===//
 /// @brief Pass to detect the maximal static control parts (Scops) of a
 /// function.
 class ScopDetection : public FunctionPass {
   //===--------------------------------------------------------------------===//

include/polly/TempScopInfo.h

 namespace llvm {
 class DataLayout;
 }
 
 using namespace llvm;
 
 namespace polly {
 
-extern bool PollyDelinearize;
-
 //===---------------------------------------------------------------------===//
 /// @brief A memory access described by a SCEV expression and the access type.
 class IRAccess {
 public:
   Value *BaseAddress;
 
   const SCEV *Offset;
 

lib/Analysis/Dependences.cpp

 #include <isl/options.h>
 #include <isl/set.h>
 
 using namespace polly;
 using namespace llvm;
 
 #define DEBUG_TYPE "polly-dependence"
 
-static cl::opt<int> OptComputeOut(
-    "polly-dependences-computeout",
-    cl::desc("Bound the dependence analysis by a maximal amount of "
-             "computational steps"),
-    cl::Hidden, cl::init(250000), cl::ZeroOrMore, cl::cat(PollyCategory));
-
-static cl::opt<bool> LegalityCheckDisabled(
-    "disable-polly-legality", cl::desc("Disable polly legality check"),
-    cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
-
-enum AnalysisType { VALUE_BASED_ANALYSIS, MEMORY_BASED_ANALYSIS };
-
-static cl::opt<enum AnalysisType> OptAnalysisType(
-    "polly-dependences-analysis-type",
-    cl::desc("The kind of dependence analysis to use"),
-    cl::values(clEnumValN(VALUE_BASED_ANALYSIS, "value-based",
-                          "Exact dependences without transitive dependences"),
-               clEnumValN(MEMORY_BASED_ANALYSIS, "memory-based",
-                          "Overapproximation of dependences"),
-               clEnumValEnd),
-    cl::Hidden, cl::init(VALUE_BASED_ANALYSIS), cl::ZeroOrMore,
-    cl::cat(PollyCategory));
-
 //===----------------------------------------------------------------------===//
 Dependences::Dependences() : ScopPass(ID) { RAW = WAR = WAW = nullptr; }
 
 void Dependences::collectInfo(Scop &S, isl_union_map **Read,
                               isl_union_map **Write, isl_union_map **MayWrite,
                               isl_union_map **AccessSchedule,
                               isl_union_map **StmtSchedule) {
   isl_space *Space = S.getParamSpace();
void Dependences::calculateDependences(Scop &S) {
   Schedule =
       isl_union_map_union(AccessSchedule, isl_union_map_copy(StmtSchedule));
 
   Read = isl_union_map_coalesce(Read);
   Write = isl_union_map_coalesce(Write);
   MayWrite = isl_union_map_coalesce(MayWrite);
 
   long MaxOpsOld = isl_ctx_get_max_operations(S.getIslCtx());
-  isl_ctx_set_max_operations(S.getIslCtx(), OptComputeOut);
+  isl_ctx_set_max_operations(S.getIslCtx(), PollyDependenceComputeOut);
   isl_options_set_on_error(S.getIslCtx(), ISL_ON_ERROR_CONTINUE);
 
   DEBUG(dbgs() << "Read: " << Read << "\n";
         dbgs() << "Write: " << Write << "\n";
         dbgs() << "MayWrite: " << MayWrite << "\n";
         dbgs() << "Schedule: " << Schedule << "\n");
 
   // The pointers below will be set by the subsequent calls to
   // isl_union_map_compute_flow.
   RAW = WAW = WAR = RED = nullptr;
 
-  if (OptAnalysisType == VALUE_BASED_ANALYSIS) {
+  if (PollyDependenceAnalysisType == VALUE_BASED_ANALYSIS) {
     isl_union_map_compute_flow(
         isl_union_map_copy(Read), isl_union_map_copy(Write),
         isl_union_map_copy(MayWrite), isl_union_map_copy(Schedule), &RAW,
         nullptr, nullptr, nullptr);
 
     isl_union_map_compute_flow(
         isl_union_map_copy(Write), isl_union_map_copy(Write),
         isl_union_map_copy(Read), isl_union_map_copy(Schedule), &WAW, &WAR,
bool Dependences::runOnScop(Scop &S) {
   calculateDependences(S);
 
   return false;
 }
 
 bool Dependences::isValidScattering(StatementToIslMapTy *NewScattering) {
   Scop &S = getCurScop();
 
-  if (LegalityCheckDisabled)
+  if (PollyDependenceNoLegalityCheck)
     return true;
 
   isl_union_map *Dependences = getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR);
   isl_space *Space = S.getParamSpace();
   isl_union_map *Scattering = isl_union_map_empty(Space);
 
   isl_space *ScatteringSpace = 0;
 

lib/Analysis/ScopDetection.cpp

 #include "llvm/Support/Debug.h"
 #include <set>
 
 using namespace llvm;
 using namespace polly;
 
 #define DEBUG_TYPE "polly-detect"
 
-static cl::opt<bool>
-    DetectScopsWithoutLoops("polly-detect-scops-in-functions-without-loops",
-                            cl::desc("Detect scops in functions without loops"),
-                            cl::Hidden, cl::init(false), cl::ZeroOrMore,
-                            cl::cat(PollyCategory));
-
-static cl::opt<bool>
-    DetectRegionsWithoutLoops("polly-detect-scops-in-regions-without-loops",
-                              cl::desc("Detect scops in regions without loops"),
-                              cl::Hidden, cl::init(false), cl::ZeroOrMore,
-                              cl::cat(PollyCategory));
-
-static cl::opt<std::string> OnlyFunction(
-    "polly-only-func",
-    cl::desc("Only run on functions that contain a certain string"),
-    cl::value_desc("string"), cl::ValueRequired, cl::init(""),
-    cl::cat(PollyCategory));
-
-static cl::opt<std::string> OnlyRegion(
-    "polly-only-region",
-    cl::desc("Only run on certain regions (The provided identifier must "
-             "appear in the name of the region's entry block"),
-    cl::value_desc("identifier"), cl::ValueRequired, cl::init(""),
-    cl::cat(PollyCategory));
-
-static cl::opt<bool>
-    IgnoreAliasing("polly-ignore-aliasing",
-                   cl::desc("Ignore possible aliasing of the array bases"),
-                   cl::Hidden, cl::init(false), cl::ZeroOrMore,
-                   cl::cat(PollyCategory));
-
-bool polly::PollyUseRuntimeAliasChecks;
-static cl::opt<bool, true> XPollyUseRuntimeAliasChecks(
-    "polly-use-runtime-alias-checks",
-    cl::desc("Use runtime alias checks to resolve possible aliasing."),
-    cl::location(PollyUseRuntimeAliasChecks), cl::Hidden, cl::ZeroOrMore,
-    cl::init(true), cl::cat(PollyCategory));
-
-static cl::opt<bool>
-    ReportLevel("polly-report",
-                cl::desc("Print information about the activities of Polly"),
-                cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
-
-static cl::opt<bool>
-    AllowNonAffine("polly-allow-nonaffine",
-                   cl::desc("Allow non affine access functions in arrays"),
-                   cl::Hidden, cl::init(false), cl::ZeroOrMore,
-                   cl::cat(PollyCategory));
-
-static cl::opt<bool, true>
-    TrackFailures("polly-detect-track-failures",
-                  cl::desc("Track failure strings in detecting scop regions"),
-                  cl::location(PollyTrackFailures), cl::Hidden, cl::ZeroOrMore,
-                  cl::init(true), cl::cat(PollyCategory));
-
-static cl::opt<bool> KeepGoing("polly-detect-keep-going",
-                               cl::desc("Do not fail on the first error."),
-                               cl::Hidden, cl::ZeroOrMore, cl::init(false),
-                               cl::cat(PollyCategory));
-
-static cl::opt<bool, true>
-    PollyDelinearizeX("polly-delinearize",
-                      cl::desc("Delinearize array access functions"),
-                      cl::location(PollyDelinearize), cl::Hidden,
-                      cl::ZeroOrMore, cl::init(false), cl::cat(PollyCategory));
-
-static cl::opt<bool>
-    VerifyScops("polly-detect-verify",
-                cl::desc("Verify the detected SCoPs after each transformation"),
-                cl::Hidden, cl::init(false), cl::ZeroOrMore,
-                cl::cat(PollyCategory));
-
-bool polly::PollyTrackFailures = false;
-bool polly::PollyDelinearize = false;
 StringRef polly::PollySkipFnAttr = "polly.skip.fn";
 
 //===----------------------------------------------------------------------===//
 // Statistics.
 
 STATISTIC(ValidRegion, "Number of regions that a valid part of Scop");
 
 class DiagnosticScopFound : public DiagnosticInfo {

 //===----------------------------------------------------------------------===//
 // ScopDetection.
 
 ScopDetection::ScopDetection() : FunctionPass(ID) {
   if (!PollyUseRuntimeAliasChecks)
     return;
 
   // Disable runtime alias checks if we ignore aliasing all together.
-  if (IgnoreAliasing) {
+  if (PollyIgnoreAliasing) {
     PollyUseRuntimeAliasChecks = false;
     return;
   }
 
-  if (AllowNonAffine) {
+  if (PollyAllowNonAffine) {
     DEBUG(errs() << "WARNING: We disable runtime alias checks as non affine "
                     "accesses are enabled.\n");
     PollyUseRuntimeAliasChecks = false;
   }
 
 #ifdef CLOOG_FOUND
   if (PollyCodeGenChoice == CODEGEN_CLOOG) {
     DEBUG(errs() << "WARNING: We disable runtime alias checks as the cloog "
for (const SCEVUnknown *BasePointer : Context.NonAffineAccesses) {
     }
 
     // Second step: find array shape.
     SE->findArrayDimensions(Terms, Shape->DelinearizedSizes,
                             Context.ElementSize[BasePointer]);
 
     // No array shape derived.
     if (Shape->DelinearizedSizes.empty()) {
-      if (AllowNonAffine)
+      if (PollyAllowNonAffine)
         continue;
 
       for (const auto &Pair : Context.Accesses[BasePointer]) {
         const Instruction *Insn = Pair.first;
         const SCEV *AF = Pair.second;
 
         if (!isAffineExpr(&Context.CurRegion, AF, *SE, BaseValue)) {
           invalid<ReportNonAffineAccess>(Context, /*Assert=*/true, AF, Insn,
                                          BaseValue);
-          if (!KeepGoing)
+          if (!PollyKeepGoing)
             return false;
         }
       }
       continue;
     }
 
     // Third step: compute the access functions for each subscript.
     //
for (const auto &Pair : Context.Accesses[BasePointer]) {
         for (const SCEV *S : Acc->DelinearizedSubscripts)
           if (!isAffineExpr(&Context.CurRegion, S, *SE, BaseValue))
             IsNonAffine = true;
       }
 
       // (Possibly) report non affine access
       if (IsNonAffine) {
         BasePtrHasNonAffine = true;
-        if (!AllowNonAffine)
+        if (!PollyAllowNonAffine)
           invalid<ReportNonAffineAccess>(Context, /*Assert=*/true, AF, Insn,
                                          BaseValue);
-        if (!KeepGoing && !AllowNonAffine)
+        if (!PollyKeepGoing && !PollyAllowNonAffine)
           return false;
       }
     }
 
     if (!BasePtrHasNonAffine)
       InsnToMemAcc.insert(TempMemoryAccesses.begin(), TempMemoryAccesses.end());
   }
   return true;
if (Context.ElementSize.count(BasePointer)) {
     Context.ElementSize[BasePointer] = Size;
   }
 
   if (PollyDelinearize) {
     Context.Accesses[BasePointer].push_back({&Inst, AccessFunction});
 
     if (!isAffineExpr(&Context.CurRegion, AccessFunction, *SE, BaseValue))
       Context.NonAffineAccesses.insert(BasePointer);
-  } else if (!AllowNonAffine) {
+  } else if (!PollyAllowNonAffine) {
     if (!isAffineExpr(&Context.CurRegion, AccessFunction, *SE, BaseValue))
       return invalid<ReportNonAffineAccess>(Context, /*Assert=*/true,
                                             AccessFunction, &Inst, BaseValue);
   }
 
   // FIXME: Alias Analysis thinks IntToPtrInst aliases with alloca instructions
   // created by IndependentBlocks Pass.
   if (IntToPtrInst *Inst = dyn_cast<IntToPtrInst>(BaseValue))
     return invalid<ReportIntToPtr>(Context, /*Assert=*/true, Inst);
 
-  if (IgnoreAliasing)
+  if (PollyIgnoreAliasing)
     return true;
 
   // Check if the base pointer of the memory access does alias with
   // any other pointer. This cannot be handled at the moment.
   AAMDNodes AATags;
   Inst.getAAMetadata(AATags);
   AliasSet &AS = Context.AST.getAliasSetForPointer(
       BaseValue, AliasAnalysis::UnknownSize, AATags);
bool ScopDetection::isValidMemoryAccess(Instruction &Inst,
 
   return true;
 }
 
 bool ScopDetection::isValidInstruction(Instruction &Inst,
                                        DetectionContext &Context) const {
   if (PHINode *PN = dyn_cast<PHINode>(&Inst))
     if (!canSynthesize(PN, LI, SE, &Context.CurRegion)) {
-      if (SCEVCodegen)
+      if (PollySCEVCodegen)
         return invalid<ReportPhiNodeRefInRegion>(Context, /*Assert=*/true,
                                                  &Inst);
       else
         return invalid<ReportNonCanonicalPhiNode>(Context, /*Assert=*/true,
                                                   &Inst);
     }
 
   // We only check the call instruction but not invoke instruction.
bool ScopDetection::isValidInstruction(Instruction &Inst,
   if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst))
     return isValidMemoryAccess(Inst, Context);
 
   // We do not know this instruction, therefore we assume it is invalid.
   return invalid<ReportUnknownInst>(Context, /*Assert=*/true, &Inst);
 }
 
 bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const {
-  if (!SCEVCodegen) {
+  if (!PollySCEVCodegen) {
     // If code generation is not in scev based mode, we need to ensure that
     // each loop has a canonical induction variable.
     PHINode *IndVar = L->getCanonicalInductionVariable();
     if (!IndVar)
       return invalid<ReportLoopHeader>(Context, /*Assert=*/true, L);
   }
 
   // Is the loop count affine?
for (auto &SubRegion : R) {
     } else {
       Count += eraseAllChildren(Regs, *SubRegion);
     }
   }
   return Count;
 }
 
 void ScopDetection::findScops(Region &R) {
-  if (!DetectRegionsWithoutLoops && regionWithoutLoops(R, LI))
+  if (!PollyDetectScopsInRegionsWithoutLoops && regionWithoutLoops(R, LI))
     return;
 
   bool IsValidRegion = isValidRegion(R);
   bool HasErrors = RejectLogs.count(&R) > 0;
 
   if (IsValidRegion && !HasErrors) {
     ++ValidRegion;
     ValidRegions.insert(&R);
void ScopDetection::findScops(Region &R) {
   }
 }
 
 bool ScopDetection::allBlocksValid(DetectionContext &Context) const {
   Region &R = Context.CurRegion;
 
   for (const BasicBlock *BB : R.blocks()) {
     Loop *L = LI->getLoopFor(BB);
-    if (L && L->getHeader() == BB && (!isValidLoop(L, Context) && !KeepGoing))
+    if (L && L->getHeader() == BB &&
+        (!isValidLoop(L, Context) && !PollyKeepGoing))
       return false;
   }
 
   for (BasicBlock *BB : R.blocks())
-    if (!isValidCFG(*BB, Context) && !KeepGoing)
+    if (!isValidCFG(*BB, Context) && !PollyKeepGoing)
       return false;
 
   for (BasicBlock *BB : R.blocks())
     for (BasicBlock::iterator I = BB->begin(), E = --BB->end(); I != E; ++I)
-      if (!isValidInstruction(*I, Context) && !KeepGoing)
+      if (!isValidInstruction(*I, Context) && !PollyKeepGoing)
         return false;
 
   if (!hasAffineMemoryAccesses(Context))
     return false;
 
   return true;
 }
 
bool ScopDetection::isValidRegion(DetectionContext &Context) const {
 
   DEBUG(dbgs() << "Checking region: " << R.getNameStr() << "\n\t");
 
   if (R.isTopLevelRegion()) {
     DEBUG(dbgs() << "Top level region is invalid"; dbgs() << "\n");
     return false;
   }
 
-  if (!R.getEntry()->getName().count(OnlyRegion)) {
+  if (!R.getEntry()->getName().count(PollyOnlyRegion)) {
     DEBUG({
       dbgs() << "Region entry does not match -polly-region-only";
       dbgs() << "\n";
     });
     return false;
   }
 
   if (!R.getEnteringBlock()) {
else {
       }
     }
   }
 }
 
 bool ScopDetection::runOnFunction(llvm::Function &F) {
   LI = &getAnalysis<LoopInfo>();
   RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
-  if (!DetectScopsWithoutLoops && LI->empty())
+  if (!PollyDetectScopsInFunctionsWithoutLoops && LI->empty())
     return false;
 
   AA = &getAnalysis<AliasAnalysis>();
   SE = &getAnalysis<ScalarEvolution>();
   Region *TopRegion = RI->getTopLevelRegion();
 
   releaseMemory();
 
-  if (OnlyFunction != "" && !F.getName().count(OnlyFunction))
+  if (PollyOnlyFunction != "" && !F.getName().count(PollyOnlyFunction))
     return false;
 
   if (!isValidFunction(F))
     return false;
 
   findScops(*TopRegion);
 
   // Only makes sense when we tracked errors.
   if (PollyTrackFailures) {
     emitMissedRemarksForValidRegions(F, ValidRegions);
     emitMissedRemarksForLeaves(F, TopRegion);
   }
 
   for (const Region *R : ValidRegions)
     emitValidRemarks(F, R);
 
-  if (ReportLevel >= 1)
+  if (PollyDetectionReport)
     printLocations(F);
 
   return false;
 }
 
 void polly::ScopDetection::verifyRegion(const Region &R) const {
   assert(isMaxRegionInScop(R) && "Expect R is a valid region.");
   DetectionContext Context(const_cast<Region &>(R), *AA, true /*verifying*/);
   isValidRegion(Context);
 }
 
 void polly::ScopDetection::verifyAnalysis() const {
-  if (!VerifyScops)
+  if (!PollyDetectionVerify)
     return;
 
   for (const Region *R : ValidRegions)
     verifyRegion(*R);
 }
 
 void ScopDetection::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/ScopInfo.cpp

 using namespace llvm;
 using namespace polly;
 
 #define DEBUG_TYPE "polly-scops"
 
 STATISTIC(ScopFound, "Number of valid Scops");
 STATISTIC(RichScopFound, "Number of Scops containing a loop");
 
-// Multiplicative reductions can be disabled separately as these kind of
-// operations can overflow easily. Additive reductions and bit operations
-// are in contrast pretty stable.
-static cl::opt<bool> DisableMultiplicativeReductions(
-    "polly-disable-multiplicative-reductions",
-    cl::desc("Disable multiplicative reductions"), cl::Hidden, cl::ZeroOrMore,
-    cl::init(false), cl::cat(PollyCategory));
-
-static cl::opt<unsigned> RunTimeChecksMaxParameters(
-    "polly-rtc-max-parameters",
-    cl::desc("The maximal number of parameters allowed in RTCs."), cl::Hidden,
-    cl::ZeroOrMore, cl::init(8), cl::cat(PollyCategory));
-
 /// Translate a 'const SCEV *' expression in an isl_pw_aff.
 struct SCEVAffinator : public SCEVVisitor<SCEVAffinator, isl_pw_aff *> {
 public:
   /// @brief Translate a 'const SCEV *' to an isl_pw_aff.
   ///
   /// @param Stmt The location at which the scalar evolution expression
   ///             is evaluated.
   /// @param Expr The expression that is translated.
case Instruction::Xor:
     return MemoryAccess::RT_BXOR;
   case Instruction::And:
     return MemoryAccess::RT_BAND;
   case Instruction::FMul:
     if (!BinOp->hasUnsafeAlgebra())
       return MemoryAccess::RT_NONE;
   // Fall through
   case Instruction::Mul:
-    if (DisableMultiplicativeReductions)
+    if (PollyDisableMultiplicativeReductions)
       return MemoryAccess::RT_NONE;
     return MemoryAccess::RT_MUL;
   default:
     return MemoryAccess::RT_NONE;
   }
 }
 //===----------------------------------------------------------------------===//
 

 }
 
 ScopStmt::ScopStmt(Scop &parent, TempScop &tempScop, const Region &CurRegion,
                    BasicBlock &bb, SmallVectorImpl<Loop *> &Nest,
                    SmallVectorImpl<unsigned> &Scatter)
     : Parent(parent), BB(&bb), IVS(Nest.size()), NestLoops(Nest.size()) {
   // Setup the induction variables.
   for (unsigned i = 0, e = Nest.size(); i < e; ++i) {
-    if (!SCEVCodegen) {
+    if (!PollySCEVCodegen) {
       PHINode *PN = Nest[i]->getCanonicalInductionVariable();
       assert(PN && "Non canonical IV in Scop!");
       IVS[i] = PN;
     }
     NestLoops[i] = Nest[i];
   }
 
   BaseName = getIslCompatibleName("Stmt_", &bb, "");
void ScopStmt::collectCandiateReductionLoads(
   if (!BinOp->isCommutative() || !BinOp->isAssociative())
     return;
 
   // Skip if the binary operator is outside the current SCoP
   if (BinOp->getParent() != Store->getParent())
     return;
 
   // Skip if it is a multiplicative reduction and we disabled them
-  if (DisableMultiplicativeReductions &&
+  if (PollyDisableMultiplicativeReductions &&
       (BinOp->getOpcode() == Instruction::Mul ||
        BinOp->getOpcode() == Instruction::FMul))
     return;
 
   // Check the binary operator operands for a candidate load
   auto *PossibleLoad0 = dyn_cast<LoadInst>(BinOp->getOperand(0));
   auto *PossibleLoad1 = dyn_cast<LoadInst>(BinOp->getOperand(1));
   if (!PossibleLoad0 && !PossibleLoad1)
static int buildMinMaxAccess(__isl_take isl_set *Set, void *User) {
   //            6          |     0.01
   //            7          |     0.04
   //            8          |     0.12
   //            9          |     0.40
   //           10          |     1.54
   //           11          |     6.78
   //           12          |    30.38
   //
-  if (isl_set_n_param(Set) > RunTimeChecksMaxParameters) {
+  if (isl_set_n_param(Set) > PollyRunTimeChecksMaxParameters) {
     unsigned InvolvedParams = 0;
     for (unsigned u = 0, e = isl_set_n_param(Set); u < e; u++)
       if (isl_set_involves_dims(Set, isl_dim_param, u, 1))
         InvolvedParams++;
 
-    if (InvolvedParams > RunTimeChecksMaxParameters) {
+    if (InvolvedParams > PollyRunTimeChecksMaxParameters) {
       isl_set_free(Set);
       return -1;
     }
   }
 
   MinPMA = isl_set_lexmin_pw_multi_aff(isl_set_copy(Set));
   MaxPMA = isl_set_lexmax_pw_multi_aff(isl_set_copy(Set));
 

lib/Analysis/TempScopInfo.cpp

 //===---------- TempScopInfo.cpp  - Extract TempScops ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Collect information about the control flow regions detected by the Scop
 // detection, such that this information can be translated info its polyhedral
 // representation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "polly/TempScopInfo.h"
+#include "polly/Options.h"
 #include "polly/ScopDetection.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/CodeGen/BlockGenerators.h"
 #include "polly/Support/GICHelper.h"
 #include "polly/Support/SCEVValidator.h"
 #include "polly/Support/ScopHelper.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/AliasAnalysis.h"

lib/CodeGen/BlockGenerators.cpp

 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpander.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
 using namespace llvm;
 using namespace polly;
 
-static cl::opt<bool>
-    Aligned("enable-polly-aligned",
-            cl::desc("Assumed aligned memory accesses."), cl::Hidden,
-            cl::value_desc("OpenMP code generation enabled if true"),
-            cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
-
-static cl::opt<bool, true>
-    SCEVCodegenF("polly-codegen-scev",
-                 cl::desc("Use SCEV based code generation."), cl::Hidden,
-                 cl::location(SCEVCodegen), cl::init(false), cl::ZeroOrMore,
-                 cl::cat(PollyCategory));
-
-bool polly::SCEVCodegen;
-
 bool polly::canSynthesize(const Instruction *I, const llvm::LoopInfo *LI,
                           ScalarEvolution *SE, const Region *R) {
-  if (SCEVCodegen) {
+  if (PollySCEVCodegen) {
     if (!I || !SE->isSCEVable(I->getType()))
       return false;
 
     if (const SCEV *Scev = SE->getSCEV(const_cast<Instruction *>(I)))
       if (!isa<SCEVCouldNotCompute>(Scev))
         if (!hasScalarDepsInsideRegion(Scev, R))
           return true;
 

 }
 
 Value *BlockGenerator::getNewValue(const Value *Old, ValueMapT &BBMap,
                                    ValueMapT &GlobalMap, LoopToScevMapT &LTS,
                                    Loop *L) {
   if (Value *New = lookupAvailableValue(Old, BBMap, GlobalMap))
     return New;
 
-  if (SCEVCodegen && SE.isSCEVable(Old->getType()))
+  if (PollySCEVCodegen && SE.isSCEVable(Old->getType()))
     if (const SCEV *Scev = SE.getSCEVAtScope(const_cast<Value *>(Old), L)) {
       if (!isa<SCEVCouldNotCompute>(Scev)) {
         const SCEV *NewScev = apply(Scev, LTS, SE);
         ValueToValueMap VTV;
         VTV.insert(BBMap.begin(), BBMap.end());
         VTV.insert(GlobalMap.begin(), GlobalMap.end());
         NewScev = SCEVParameterRewriter::rewrite(NewScev, SE, VTV);
         SCEVExpander Expander(SE, "polly");
VectorBlockGenerator::generateStrideOneLoad(const LoadInst *Load,
 
   Value *NewPointer = nullptr;
   NewPointer = generateLocationAccessed(Load, Pointer, ScalarMaps[Offset],
                                         GlobalMaps[Offset], VLTS[Offset]);
   Value *VectorPtr =
       Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
   LoadInst *VecLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_vec_full");
-  if (!Aligned)
+  if (!PollyAssumeAligned)
     VecLoad->setAlignment(8);
 
   if (NegativeStride) {
     SmallVector<Constant *, 16> Indices;
     for (int i = VectorWidth - 1; i >= 0; i--)
       Indices.push_back(ConstantInt::get(Builder.getInt32Ty(), i));
     Constant *SV = llvm::ConstantVector::get(Indices);
     Value *RevVecLoad = Builder.CreateShuffleVector(
Value *VectorBlockGenerator::generateStrideZeroLoad(const LoadInst *Load,
   Type *VectorPtrType = getVectorPtrTy(Pointer, 1);
   Value *NewPointer =
       generateLocationAccessed(Load, Pointer, BBMap, GlobalMaps[0], VLTS[0]);
   Value *VectorPtr = Builder.CreateBitCast(NewPointer, VectorPtrType,
                                            Load->getName() + "_p_vec_p");
   LoadInst *ScalarLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_splat_one");
 
-  if (!Aligned)
+  if (!PollyAssumeAligned)
     ScalarLoad->setAlignment(8);
 
   Constant *SplatVector = Constant::getNullValue(
       VectorType::get(Builder.getInt32Ty(), getVectorWidth()));
 
   Value *VectorLoad = Builder.CreateShuffleVector(
       ScalarLoad, ScalarLoad, SplatVector, Load->getName() + "_p_splat");
   return VectorLoad;
VectorBlockGenerator::generateUnknownStrideLoad(const LoadInst *Load,
   }
 
   return Vector;
 }
 
 void VectorBlockGenerator::generateLoad(const LoadInst *Load,
                                         ValueMapT &VectorMap,
                                         VectorValueMapT &ScalarMaps) {
-  if (PollyVectorizerChoice >= VECTORIZER_FIRST_NEED_GROUPED_UNROLL ||
+  if (PollyVectorizerChoice >= VECTORIZER_UNROLL_ONLY ||
       !VectorType::isValidElementType(Load->getType())) {
     for (int i = 0; i < getVectorWidth(); i++)
       ScalarMaps[i][Load] =
           generateScalarLoad(Load, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
     return;
   }
 
   const MemoryAccess &Access = Statement.getAccessFor(Load);
if (Access.isStrideOne(isl_map_copy(Schedule))) {
     Type *VectorPtrType = getVectorPtrTy(Pointer, getVectorWidth());
     Value *NewPointer = generateLocationAccessed(Store, Pointer, ScalarMaps[0],
                                                  GlobalMaps[0], VLTS[0]);
 
     Value *VectorPtr =
         Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
     StoreInst *Store = Builder.CreateStore(Vector, VectorPtr);
 
-    if (!Aligned)
+    if (!PollyAssumeAligned)
       Store->setAlignment(8);
   } else {
     for (unsigned i = 0; i < ScalarMaps.size(); i++) {
       Value *Scalar = Builder.CreateExtractElement(Vector, Builder.getInt32(i));
       Value *NewPointer = generateLocationAccessed(
           Store, Pointer, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
       Builder.CreateStore(Scalar, NewPointer);
     }

lib/CodeGen/IslCodeGeneration.cpp

 // Transformation passes can update the schedule (execution order) of statements
 // in the Scop. ISL is used to generate an abstract syntax tree that reflects
 // the updated execution order. This clast is used to create new LLVM-IR that is
 // computationally equivalent to the original control flow region, but executes
 // its code in the new execution order defined by the changed scattering.
 //
 //===----------------------------------------------------------------------===//
 #include "polly/Config/config.h"
+#include "polly/Options.h"
 #include "polly/CodeGen/IslExprBuilder.h"
 #include "polly/CodeGen/BlockGenerators.h"
 #include "polly/CodeGen/CodeGeneration.h"
 #include "polly/CodeGen/IslAst.h"
 #include "polly/CodeGen/LoopGenerators.h"
 #include "polly/CodeGen/Utils.h"
 #include "polly/Dependences.h"
 #include "polly/LinkAllPasses.h"

lib/Options.cpp

+//===---------- Options.cpp - Initialize the Polly Module -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Home of all options available in Polly.
+//
+// TODO: Sort/categorize the options
+//
+//===----------------------------------------------------------------------===//
+
+#include "polly/Options.h"
+
+using namespace llvm;
+using namespace polly;
+
+namespace polly {
+bool PollyKeepGoing;
+bool PollyDelinearize;
+bool PollyTrackFailures;
+bool PollyDisableTiling;
+bool PollyAssumeAligned;
+bool PollyAllowNonAffine;
+bool PollyIgnoreAliasing;
+bool PollyDetectionVerify;
+bool PollyDetectionReport;
+bool PollyUseRuntimeAliasChecks;
+bool PollyDependenceNoLegalityCheck;
+bool PollyDisableMultiplicativeReductions;
+bool PollyDetectScopsInRegionsWithoutLoops;
+bool PollyDetectScopsInFunctionsWithoutLoops;
+
+unsigned PollyDependenceComputeOut;
+unsigned PollyRunTimeChecksMaxParameters;
+
+enum CodeGenChoice PollyCodeGenChoice;
+enum VectorizerChoice PollyVectorizerChoice;
+enum AnalysisType PollyDependenceAnalysisType;
+
+std::string PollyOnlyRegion;
+std::string PollyOnlyFunction;
+}
+
+static cl::opt<bool, true> PollyDetectScopsInFunctionsWithoutLoopsX(
+    "polly-detect-scops-in-functions-without-loops",
+    cl::desc("Detect scops in functions without loops"),
+    cl::location(PollyDetectScopsInFunctionsWithoutLoops), cl::Hidden,
+    cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyDetectScopsInRegionsWithoutLoopsX(
+    "polly-detect-scops-in-regions-without-loops",
+    cl::desc("Detect scops in regions without loops"),
+    cl::location(PollyDetectScopsInRegionsWithoutLoops), cl::Hidden,
+    cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyIgnoreAliasingX(
+    "polly-ignore-aliasing",
+    cl::desc("Ignore possible aliasing of the array bases"),
+    cl::location(PollyIgnoreAliasing), cl::Hidden, cl::init(false),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyUseRuntimeAliasChecksX(
+    "polly-use-runtime-alias-checks",
+    cl::desc("Use runtime alias checks to resolve possible aliasing."),
+    cl::location(PollyUseRuntimeAliasChecks), cl::Hidden, cl::ZeroOrMore,
+    cl::init(true), cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyAllowNonAffineX(
+    "polly-allow-nonaffine",
+    cl::desc("Allow non affine access functions in arrays"),
+    cl::location(PollyAllowNonAffine), cl::Hidden, cl::init(false),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyTrackFailuresX(
+    "polly-detect-track-failures",
+    cl::desc("Track failure strings in detecting scop regions"),
+    cl::location(PollyTrackFailures), cl::Hidden, cl::ZeroOrMore,
+    cl::init(true), cl::cat(PollyCategory));
+
+static cl::opt<bool, true>
+    PollyDelinearizeX("polly-delinearize",
+                      cl::desc("Delinearize array access functions"),
+                      cl::location(PollyDelinearize), cl::Hidden,
+                      cl::ZeroOrMore, cl::init(false), cl::cat(PollyCategory));
+
+static cl::opt<std::string, true> PollyOnlyFunctionX(
+    "polly-only-func",
+    cl::desc("Only run on functions that contain a certain string"),
+    cl::location(PollyOnlyFunction), cl::value_desc("string"),
+    cl::ValueRequired, cl::init(""), cl::cat(PollyCategory));
+
+static cl::opt<std::string, true> PollyOnlyRegionX(
+    "polly-only-region",
+    cl::desc("Only run on certain regions (The provided identifier must "
+             "appear in the name of the region's entry block"),
+    cl::location(PollyOnlyRegion), cl::value_desc("identifier"),
+    cl::ValueRequired, cl::init(""), cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyDetectionReportX(
+    "polly-report", cl::desc("Print information about the activities of Polly"),
+    cl::location(PollyDetectionReport), cl::init(false), cl::ZeroOrMore,
+    cl::cat(PollyCategory));
+
+static cl::opt<bool, true>
+    PollyKeepGoingX("polly-detect-keep-going",
+                    cl::desc("Do not fail on the first error."),
+                    cl::location(PollyKeepGoing), cl::Hidden, cl::ZeroOrMore,
+                    cl::init(false), cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyDetectionVerifyX(
+    "polly-detect-verify",
+    cl::desc("Verify the detected SCoPs after each transformation"),
+    cl::location(PollyDetectionVerify), cl::Hidden, cl::init(false),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+// Multiplicative reductions can be disabled separately as these kind of
+// operations can overflow easily. Additive reductions and bit operations
+// are in contrast pretty stable.
+static cl::opt<bool, true> PollyDisableMultiplicativeReductionsX(
+    "polly-disable-multiplicative-reductions",
+    cl::desc("Disable multiplicative reductions"),
+    cl::location(PollyDisableMultiplicativeReductions), cl::Hidden,
+    cl::ZeroOrMore, cl::init(false), cl::cat(PollyCategory));
+
+static cl::opt<unsigned, true> PollyRunTimeChecksMaxParametersX(
+    "polly-rtc-max-parameters",
+    cl::desc("The maximal number of parameters allowed in RTCs."),
+    cl::location(PollyRunTimeChecksMaxParameters), cl::Hidden, cl::ZeroOrMore,
+    cl::init(8), cl::cat(PollyCategory));
+
+static cl::opt<unsigned, true> PollyDependenceComputeOutX(
+    "polly-dependences-computeout",
+    cl::desc("Bound the dependence analysis by a maximal amount of "
+             "computational steps"),
+    cl::location(PollyDependenceComputeOut), cl::Hidden, cl::init(250000),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyDependenceNoLegalityCheckX(
+    "polly-dependences-no-legality-check",
+    cl::location(PollyDependenceNoLegalityCheck),
+    cl::desc("Disable polly legality check"), cl::Hidden, cl::init(false),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<enum AnalysisType, true> PollyDependenceAnalysisTypeX(
+    "polly-dependences-analysis-type",
+    cl::desc("The kind of dependence analysis to use"),
+    cl::values(clEnumValN(VALUE_BASED_ANALYSIS, "value-based",
+                          "Exact dependences without transitive dependences"),
+               clEnumValN(MEMORY_BASED_ANALYSIS, "memory-based",
+                          "Overapproximation of dependences"),
+               clEnumValEnd),
+    cl::location(PollyDependenceAnalysisType), cl::Hidden,
+    cl::init(VALUE_BASED_ANALYSIS), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true>
+    PollySCEVCodegenX("polly-codegen-scev",
+                      cl::desc("Use SCEV based code generation."), cl::Hidden,
+                      cl::location(PollySCEVCodegen), cl::init(false),
+                      cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true> PollyAssumeAlignedX(
+    "polly-assume-aligned", cl::desc("Assumed aligned memory accesses."),
+    cl::location(PollyAssumeAligned), cl::Hidden, cl::init(false),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool, true>
+    PollyDisableTilingX("polly-no-tiling",
+                        cl::desc("Disable tiling in the scheduler"),
+                        cl::location(PollyDisableTiling), cl::init(false),
+                        cl::ZeroOrMore, cl::cat(PollyCategory));

lib/Transform/ScheduleOptimizer.cpp

 // algorithm described in following paper:
 //
 // U. Bondhugula, A. Hartono, J. Ramanujam, and P. Sadayappan.
 // A Practical Automatic Polyhedral Parallelizer and Locality Optimizer.
 // In Proceedings of the 2008 ACM SIGPLAN Conference On Programming Language
 // Design and Implementation, PLDI ’08, pages 101–113. ACM, 2008.
 //===----------------------------------------------------------------------===//
 
-#include "polly/ScheduleOptimizer.h"
 #include "isl/aff.h"
 #include "isl/band.h"
 #include "isl/constraint.h"
 #include "isl/map.h"
 #include "isl/options.h"
 #include "isl/schedule.h"
 #include "isl/space.h"
 #include "polly/CodeGen/CodeGeneration.h"
 #include "polly/Dependences.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
 #include "llvm/Support/Debug.h"
 
 using namespace llvm;
 using namespace polly;
 
 #define DEBUG_TYPE "polly-opt-isl"
 
-namespace polly {
-bool DisablePollyTiling;
-}
-static cl::opt<bool, true>
-    DisableTiling("polly-no-tiling",
-                  cl::desc("Disable tiling in the scheduler"),
-                  cl::location(polly::DisablePollyTiling), cl::init(false),
-                  cl::ZeroOrMore, cl::cat(PollyCategory));
-
 static cl::opt<std::string>
     OptimizeDeps("polly-opt-optimize-only",
                  cl::desc("Only a certain kind of dependences (all/raw)"),
                  cl::Hidden, cl::init("all"), cl::ZeroOrMore,
                  cl::cat(PollyCategory));
 
 static cl::opt<std::string>
     SimplifyDeps("polly-opt-simplify-deps",
isl_union_map *IslScheduleOptimizer::getScheduleForBand(isl_band *Band,
   isl_ctx *ctx;
   isl_space *Space;
   isl_basic_map *TileMap;
   isl_union_map *TileUMap;
 
   PartialSchedule = isl_band_get_partial_schedule(Band);
   *Dimensions = isl_band_n_member(Band);
 
-  if (DisableTiling)
+  if (PollyDisableTiling)
     return PartialSchedule;
 
   // It does not make any sense to tile a band with just one dimension.
   if (*Dimensions == 1)
     return PartialSchedule;
 
   ctx = isl_union_map_get_ctx(PartialSchedule);
   Space = isl_union_map_get_space(PartialSchedule);