clang-format polly to avoid buildbot noise

llvm-svn: 212609

diff --git a/polly/include/polly/ScopDetection.h b/polly/include/polly/ScopDetection.h
index d0b588e..e62db93 100644 (file)
--- a/polly/include/polly/ScopDetection.h
+++ b/polly/include/polly/ScopDetection.h
@@ -317,7 +317,7 @@ public:
   //@{
   typedef std::map<const Region *, RejectLog>::iterator reject_iterator;
   typedef std::map<const Region *, RejectLog>::const_iterator
-  const_reject_iterator;
+      const_reject_iterator;
 
   reject_iterator reject_begin() { return RejectLogs.begin(); }
   reject_iterator reject_end() { return RejectLogs.end(); }

diff --git a/polly/lib/Analysis/Dependences.cpp b/polly/lib/Analysis/Dependences.cpp
index a9ae4b3..c4e5981 100644 (file)
--- a/polly/lib/Analysis/Dependences.cpp
+++ b/polly/lib/Analysis/Dependences.cpp
@@ -39,17 +39,15 @@ 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));
+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 };
 

diff --git a/polly/lib/Analysis/ScopDetection.cpp b/polly/lib/Analysis/ScopDetection.cpp
index fd49c9c..53c5ed7 100644 (file)
--- a/polly/lib/Analysis/ScopDetection.cpp
+++ b/polly/lib/Analysis/ScopDetection.cpp
@@ -70,52 +70,52 @@ 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));
+    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));
+    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));
+    IgnoreAliasing("polly-ignore-aliasing",
+                   cl::desc("Ignore possible aliasing of the array bases"),
+                   cl::Hidden, cl::init(false), cl::ZeroOrMore,
+                   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));
+    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));
+    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(false), cl::cat(PollyCategory));
+    TrackFailures("polly-detect-track-failures",
+                  cl::desc("Track failure strings in detecting scop regions"),
+                  cl::location(PollyTrackFailures), cl::Hidden, cl::ZeroOrMore,
+                  cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<bool> KeepGoing("polly-detect-keep-going",
                                cl::desc("Do not fail on the first error."),
@@ -123,16 +123,16 @@ static cl::opt<bool> KeepGoing("polly-detect-keep-going",
                                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));
+    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));
+    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;

diff --git a/polly/lib/Analysis/ScopGraphPrinter.cpp b/polly/lib/Analysis/ScopGraphPrinter.cpp
index 992adde..dfcbec9 100644 (file)
--- a/polly/lib/Analysis/ScopGraphPrinter.cpp
+++ b/polly/lib/Analysis/ScopGraphPrinter.cpp
@@ -187,15 +187,15 @@ static RegisterPass<ScopViewer> X("view-scops",
                                   "Polly - View Scops of function");
 
 static RegisterPass<ScopOnlyViewer>
-Y("view-scops-only",
-  "Polly - View Scops of function (with no function bodies)");
+    Y("view-scops-only",
+      "Polly - View Scops of function (with no function bodies)");
 
 static RegisterPass<ScopPrinter> M("dot-scops",
                                    "Polly - Print Scops of function");
 
 static RegisterPass<ScopOnlyPrinter>
-N("dot-scops-only",
-  "Polly - Print Scops of function (with no function bodies)");
+    N("dot-scops-only",
+      "Polly - Print Scops of function (with no function bodies)");
 
 Pass *polly::createDOTViewerPass() { return new ScopViewer(); }
 

diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
index f620b44..21cdfc0 100644 (file)
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -58,11 +58,10 @@ STATISTIC(RichScopFound, "Number of Scops containing a loop");
 // Multiplicative reductions can be disabled seperately 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<bool> DisableMultiplicativeReductions(
+    "polly-disable-multiplicative-reductions",
+    cl::desc("Disable multiplicative reductions"), cl::Hidden, cl::ZeroOrMore,
+    cl::init(false), cl::cat(PollyCategory));
 
 /// Translate a 'const SCEV *' expression in an isl_pw_aff.
 struct SCEVAffinator : public SCEVVisitor<SCEVAffinator, isl_pw_aff *> {

diff --git a/polly/lib/CodeGen/BlockGenerators.cpp b/polly/lib/CodeGen/BlockGenerators.cpp
index 0643fbe..3cfdb4b 100644 (file)
--- a/polly/lib/CodeGen/BlockGenerators.cpp
+++ b/polly/lib/CodeGen/BlockGenerators.cpp
@@ -32,14 +32,16 @@ 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));
+    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));
+    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;
 

diff --git a/polly/lib/CodeGen/CodeGeneration.cpp b/polly/lib/CodeGen/CodeGeneration.cpp
index 9fba08b..59373e5 100644 (file)
--- a/polly/lib/CodeGen/CodeGeneration.cpp
+++ b/polly/lib/CodeGen/CodeGeneration.cpp
@@ -63,20 +63,20 @@ struct isl_set;
 
 namespace polly {
 static cl::opt<bool>
-OpenMP("enable-polly-openmp", cl::desc("Generate OpenMP parallel code"),
-       cl::value_desc("OpenMP code generation enabled if true"),
-       cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+    OpenMP("enable-polly-openmp", cl::desc("Generate OpenMP parallel code"),
+           cl::value_desc("OpenMP code generation enabled if true"),
+           cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 #ifdef GPU_CODEGEN
 static cl::opt<bool>
-GPGPU("enable-polly-gpgpu", cl::desc("Generate GPU parallel code"), cl::Hidden,
-      cl::value_desc("GPGPU code generation enabled if true"), cl::init(false),
-      cl::ZeroOrMore, cl::cat(PollyCategory));
+    GPGPU("enable-polly-gpgpu", cl::desc("Generate GPU parallel code"),
+          cl::Hidden, cl::value_desc("GPGPU code generation enabled if true"),
+          cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<std::string>
-GPUTriple("polly-gpgpu-triple",
-          cl::desc("Target triple for GPU code generation"), cl::Hidden,
-          cl::init(""), cl::cat(PollyCategory));
+    GPUTriple("polly-gpgpu-triple",
+              cl::desc("Target triple for GPU code generation"), cl::Hidden,
+              cl::init(""), cl::cat(PollyCategory));
 #endif /* GPU_CODEGEN */
 
 typedef DenseMap<const char *, Value *> CharMapT;

diff --git a/polly/lib/Exchange/JSONExporter.cpp b/polly/lib/Exchange/JSONExporter.cpp
index c0ab565..506c017 100644 (file)
--- a/polly/lib/Exchange/JSONExporter.cpp
+++ b/polly/lib/Exchange/JSONExporter.cpp
@@ -42,16 +42,16 @@ STATISTIC(NewAccessMapFound, "Number of updated access functions");
 
 namespace {
 static cl::opt<std::string>
-ImportDir("polly-import-jscop-dir",
-          cl::desc("The directory to import the .jscop files from."),
-          cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
-          cl::init("."), cl::cat(PollyCategory));
+    ImportDir("polly-import-jscop-dir",
+              cl::desc("The directory to import the .jscop files from."),
+              cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
+              cl::init("."), cl::cat(PollyCategory));
 
 static cl::opt<std::string>
-ImportPostfix("polly-import-jscop-postfix",
-              cl::desc("Postfix to append to the import .jsop files."),
-              cl::Hidden, cl::value_desc("File postfix"), cl::ValueRequired,
-              cl::init(""), cl::cat(PollyCategory));
+    ImportPostfix("polly-import-jscop-postfix",
+                  cl::desc("Postfix to append to the import .jsop files."),
+                  cl::Hidden, cl::value_desc("File postfix"), cl::ValueRequired,
+                  cl::init(""), cl::cat(PollyCategory));
 
 struct JSONExporter : public ScopPass {
   static char ID;

diff --git a/polly/lib/Exchange/ScopLibExporter.cpp b/polly/lib/Exchange/ScopLibExporter.cpp
index 4d8ee6b..529a3f8 100644 (file)
--- a/polly/lib/Exchange/ScopLibExporter.cpp
+++ b/polly/lib/Exchange/ScopLibExporter.cpp
@@ -29,10 +29,10 @@ using namespace polly;
 
 namespace {
 static cl::opt<std::string>
-ExportDir("polly-export-scoplib-dir",
-          cl::desc("The directory to export the .scoplib files to."),
-          cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
-          cl::init("."), cl::cat(PollyCategory));
+    ExportDir("polly-export-scoplib-dir",
+              cl::desc("The directory to export the .scoplib files to."),
+              cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
+              cl::init("."), cl::cat(PollyCategory));
 
 class ScopLibExporter : public ScopPass {
   Scop *S;
@@ -85,8 +85,8 @@ void ScopLibExporter::getAnalysisUsage(AnalysisUsage &AU) const {
 }
 
 static RegisterPass<ScopLibExporter>
-A("polly-export-scoplib", "Polly - Export Scops with ScopLib library"
-                          " (Writes a .scoplib file for each Scop)");
+    A("polly-export-scoplib", "Polly - Export Scops with ScopLib library"
+                              " (Writes a .scoplib file for each Scop)");
 
 Pass *polly::createScopLibExporterPass() { return new ScopLibExporter(); }
 

diff --git a/polly/lib/Exchange/ScopLibImporter.cpp b/polly/lib/Exchange/ScopLibImporter.cpp
index 96b38ac..4c8bcf7 100644 (file)
--- a/polly/lib/Exchange/ScopLibImporter.cpp
+++ b/polly/lib/Exchange/ScopLibImporter.cpp
@@ -32,16 +32,16 @@ using namespace polly;
 
 namespace {
 static cl::opt<std::string>
-ImportDir("polly-import-scoplib-dir",
-          cl::desc("The directory to import the .scoplib files from."),
-          cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
-          cl::init("."), cl::cat(PollyCategory));
+    ImportDir("polly-import-scoplib-dir",
+              cl::desc("The directory to import the .scoplib files from."),
+              cl::Hidden, cl::value_desc("Directory path"), cl::ValueRequired,
+              cl::init("."), cl::cat(PollyCategory));
 
 static cl::opt<std::string>
-ImportPostfix("polly-import-scoplib-postfix",
-              cl::desc("Postfix to append to the import .scoplib files."),
-              cl::Hidden, cl::value_desc("File postfix"), cl::ValueRequired,
-              cl::init(""), cl::cat(PollyCategory));
+    ImportPostfix("polly-import-scoplib-postfix",
+                  cl::desc("Postfix to append to the import .scoplib files."),
+                  cl::Hidden, cl::value_desc("File postfix"), cl::ValueRequired,
+                  cl::init(""), cl::cat(PollyCategory));
 
 struct ScopLibImporter : public RegionPass {
   static char ID;
@@ -108,8 +108,8 @@ void ScopLibImporter::getAnalysisUsage(AnalysisUsage &AU) const {
 }
 
 static RegisterPass<ScopLibImporter>
-A("polly-import-scoplib", "Polly - Import Scops with ScopLib library"
-                          " (Reads a .scoplib file for each Scop)");
+    A("polly-import-scoplib", "Polly - Import Scops with ScopLib library"
+                              " (Reads a .scoplib file for each Scop)");
 
 Pass *polly::createScopLibImporterPass() { return new ScopLibImporter(); }
 

diff --git a/polly/lib/Support/RegisterPasses.cpp b/polly/lib/Support/RegisterPasses.cpp
index ce2a438..d55749a 100644 (file)
--- a/polly/lib/Support/RegisterPasses.cpp
+++ b/polly/lib/Support/RegisterPasses.cpp
@@ -43,8 +43,8 @@ cl::OptionCategory PollyCategory("Polly Options",
                                  "Configure the polly loop optimizer");
 
 static cl::opt<bool>
-PollyEnabled("polly", cl::desc("Enable the polly optimizer (only at -O3)"),
-             cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+    PollyEnabled("polly", cl::desc("Enable the polly optimizer (only at -O3)"),
+                 cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 enum OptimizerChoice {
   OPTIMIZER_NONE,
@@ -111,39 +111,37 @@ static cl::opt<polly::VectorizerChoice, true> Vectorizer(
     cl::location(PollyVectorizerChoice), cl::init(polly::VECTORIZER_NONE),
     cl::ZeroOrMore, cl::cat(PollyCategory));
 
-static cl::opt<bool>
-ImportJScop("polly-import",
-            cl::desc("Export the polyhedral description of the detected Scops"),
-            cl::Hidden, cl::init(false), cl::ZeroOrMore,
-            cl::cat(PollyCategory));
+static cl::opt<bool> ImportJScop(
+    "polly-import",
+    cl::desc("Export the polyhedral description of the detected Scops"),
+    cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
-static cl::opt<bool>
-ExportJScop("polly-export",
-            cl::desc("Export the polyhedral description of the detected Scops"),
-            cl::Hidden, cl::init(false), cl::ZeroOrMore,
-            cl::cat(PollyCategory));
+static cl::opt<bool> ExportJScop(
+    "polly-export",
+    cl::desc("Export the polyhedral description of the detected Scops"),
+    cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> DeadCodeElim("polly-run-dce",
                                   cl::desc("Run the dead code elimination"),
                                   cl::Hidden, cl::init(true), cl::ZeroOrMore,
                                   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::init(false), cl::ZeroOrMore, 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::init(false), cl::ZeroOrMore, 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> 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));
+    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",
@@ -152,9 +150,9 @@ static cl::opt<bool> PollyOnlyPrinter(
     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));
+    CFGPrinter("polly-view-cfg",
+               cl::desc("Show the Polly CFG right after code generation"),
+               cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 namespace polly {
 void initializePollyPasses(PassRegistry &Registry) {
@@ -325,6 +323,6 @@ registerPollyEarlyAsPossiblePasses(const llvm::PassManagerBuilder &Builder,
 ///   optimizations behind us, such that inefficiencies on the low level can
 ///   be optimized away.
 static llvm::RegisterStandardPasses
-RegisterPollyOptimizer(llvm::PassManagerBuilder::EP_EarlyAsPossible,
-                       registerPollyEarlyAsPossiblePasses);
+    RegisterPollyOptimizer(llvm::PassManagerBuilder::EP_EarlyAsPossible,
+                           registerPollyEarlyAsPossiblePasses);
 }

diff --git a/polly/lib/Transform/Pluto.cpp b/polly/lib/Transform/Pluto.cpp
index 4105679..e0ab060 100644 (file)
--- a/polly/lib/Transform/Pluto.cpp
+++ b/polly/lib/Transform/Pluto.cpp
@@ -55,15 +55,15 @@ static cl::opt<bool> PlutoParallel("polly-pluto-parallel",
                                    cl::cat(PollyCategory));
 
 static cl::opt<bool>
-PlutoInnerParallel("polly-pluto-innerpara",
-                   cl::desc("Enable inner parallelism instead of piped."),
-                   cl::Hidden, cl::init(false), cl::ZeroOrMore,
-                   cl::cat(PollyCategory));
+    PlutoInnerParallel("polly-pluto-innerpara",
+                       cl::desc("Enable inner parallelism instead of piped."),
+                       cl::Hidden, cl::init(false), cl::ZeroOrMore,
+                       cl::cat(PollyCategory));
 
 static cl::opt<bool>
-PlutoIdentity("polly-pluto-identity",
-              cl::desc("Enable pluto identity transformation"), cl::Hidden,
-              cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+    PlutoIdentity("polly-pluto-identity",
+                  cl::desc("Enable pluto identity transformation"), cl::Hidden,
+                  cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> PlutoUnroll("polly-pluto-unroll",
                                  cl::desc("Enable pluto unrolling"), cl::Hidden,
@@ -91,9 +91,9 @@ static cl::opt<bool> PlutoPollyUnroll("polly-pluto-pollyunroll",
                                       cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool>
-PlutoIslDep("polly-pluto-isldep",
-            cl::desc("Enable pluto isl dependency scanning"), cl::Hidden,
-            cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+    PlutoIslDep("polly-pluto-isldep",
+                cl::desc("Enable pluto isl dependency scanning"), cl::Hidden,
+                cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> PlutoIslDepCompact(
     "polly-pluto-isldepcom", cl::desc("Enable pluto isl dependency compaction"),

diff --git a/polly/lib/Transform/ScheduleOptimizer.cpp b/polly/lib/Transform/ScheduleOptimizer.cpp
index f95a3b4..16c6e54 100644 (file)
--- a/polly/lib/Transform/ScheduleOptimizer.cpp
+++ b/polly/lib/Transform/ScheduleOptimizer.cpp
@@ -41,49 +41,47 @@ 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));
+    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));
+    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",
-             cl::desc("Dependences should be simplified (yes/no)"), cl::Hidden,
-             cl::init("yes"), cl::ZeroOrMore, cl::cat(PollyCategory));
-
-static cl::opt<int>
-MaxConstantTerm("polly-opt-max-constant-term",
-                cl::desc("The maximal constant term allowed (-1 is unlimited)"),
-                cl::Hidden, cl::init(20), cl::ZeroOrMore,
-                cl::cat(PollyCategory));
-
-static cl::opt<int>
-MaxCoefficient("polly-opt-max-coefficient",
-               cl::desc("The maximal coefficient allowed (-1 is unlimited)"),
-               cl::Hidden, cl::init(20), cl::ZeroOrMore,
-               cl::cat(PollyCategory));
+    SimplifyDeps("polly-opt-simplify-deps",
+                 cl::desc("Dependences should be simplified (yes/no)"),
+                 cl::Hidden, cl::init("yes"), cl::ZeroOrMore,
+                 cl::cat(PollyCategory));
 
-static cl::opt<std::string>
-FusionStrategy("polly-opt-fusion",
-               cl::desc("The fusion strategy to choose (min/max)"), cl::Hidden,
-               cl::init("min"), cl::ZeroOrMore, cl::cat(PollyCategory));
+static cl::opt<int> MaxConstantTerm(
+    "polly-opt-max-constant-term",
+    cl::desc("The maximal constant term allowed (-1 is unlimited)"), cl::Hidden,
+    cl::init(20), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<int> MaxCoefficient(
+    "polly-opt-max-coefficient",
+    cl::desc("The maximal coefficient allowed (-1 is unlimited)"), cl::Hidden,
+    cl::init(20), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<std::string> FusionStrategy(
+    "polly-opt-fusion", cl::desc("The fusion strategy to choose (min/max)"),
+    cl::Hidden, cl::init("min"), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<std::string>
-MaximizeBandDepth("polly-opt-maximize-bands",
-                  cl::desc("Maximize the band depth (yes/no)"), cl::Hidden,
-                  cl::init("yes"), cl::ZeroOrMore, cl::cat(PollyCategory));
-
-static cl::opt<int>
-DefaultTileSize("polly-default-tile-size",
-                cl::desc("The default tile size (if not enough were provided by"
-                         " --polly-tile-sizes)"),
-                cl::Hidden, cl::init(32), cl::ZeroOrMore,
-                cl::cat(PollyCategory));
+    MaximizeBandDepth("polly-opt-maximize-bands",
+                      cl::desc("Maximize the band depth (yes/no)"), cl::Hidden,
+                      cl::init("yes"), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<int> DefaultTileSize(
+    "polly-default-tile-size",
+    cl::desc("The default tile size (if not enough were provided by"
+             " --polly-tile-sizes)"),
+    cl::Hidden, cl::init(32), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::list<int> TileSizes("polly-tile-sizes",
                                cl::desc("A tile size"