[polly][NFC] removes using-directives to fix modules build

[cjdb]

Summary

When compiling with Clang modules enabled, polly's use of using-directives
caused the global object Target in RegisterPasses.cpp to clash with
llvm::Target. By eliminating the using-directives, we're able to get
polly to play nicely with a modules build.

[cjdb]

creates namespace alias

[cjdb]

• qualifies things that weren't caught by the modules build
• adds using-declarations for some of the more commonly used types so that they don't need to be qualified

[cjdb]

qualifies something that Clang missed, but MSVC caught

[Meinersbur]

LGTM

polly/lib/Support/PollyPasses.def

 #ifndef FUNCTION_ANALYSIS
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 #endif
 FUNCTION_ANALYSIS("polly-detect", ScopAnalysis())
 FUNCTION_ANALYSIS("polly-function-scops", ScopInfoAnalysis())
 #undef FUNCTION_ANALYSIS
 
 #ifndef FUNCTION_PASS
 #define FUNCTION_PASS(NAME, CREATE_PASS)
 #endif
 FUNCTION_PASS("polly-prepare", CodePreparationPass())
-FUNCTION_PASS("print<polly-detect>", ScopAnalysisPrinterPass(errs()))
-FUNCTION_PASS("print<polly-function-scops>", ScopInfoPrinterPass(errs()))
+FUNCTION_PASS("print<polly-detect>", ScopAnalysisPrinterPass(llvm::errs()))
+FUNCTION_PASS("print<polly-function-scops>", ScopInfoPrinterPass(llvm::errs()))
 #undef FUNCTION_PASS
 
 #ifndef SCOP_ANALYSIS
 #define SCOP_ANALYSIS(NAME, CREATE_PASS)
 #endif
-SCOP_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
+SCOP_ANALYSIS("pass-instrumentation", llvm::PassInstrumentationAnalysis(PIC))
 SCOP_ANALYSIS("polly-ast", IslAstAnalysis())
 SCOP_ANALYSIS("polly-dependences", DependenceAnalysis())
 #undef SCOP_ANALYSIS
 
 #ifndef SCOP_PASS
 #define SCOP_PASS(NAME, CREATE_PASS)
 #endif
 SCOP_PASS("polly-export-jscop", JSONExportPass())
 SCOP_PASS("polly-import-jscop", JSONImportPass())
-SCOP_PASS("print<polly-ast>", IslAstPrinterPass(outs()))
-SCOP_PASS("print<polly-dependences>", DependenceInfoPrinterPass(outs()))
+SCOP_PASS("print<polly-ast>", IslAstPrinterPass(llvm::outs()))
+SCOP_PASS("print<polly-dependences>", DependenceInfoPrinterPass(llvm::outs()))
 SCOP_PASS("polly-codegen", CodeGenerationPass())
 SCOP_PASS("polly-simplify", SimplifyPass())
-SCOP_PASS("print<polly-simplify>", SimplifyPrinterPass(outs()))
+SCOP_PASS("print<polly-simplify>", SimplifyPrinterPass(llvm::outs()))
 SCOP_PASS("polly-optree", ForwardOpTreePass())
-SCOP_PASS("print<polly-optree>", ForwardOpTreePrinterPass(outs()))
+SCOP_PASS("print<polly-optree>", ForwardOpTreePrinterPass(llvm::outs()))
 SCOP_PASS("polly-delicm", DeLICMPass())
-SCOP_PASS("print<polly-delicm>", DeLICMPrinterPass(outs()))
+SCOP_PASS("print<polly-delicm>", DeLICMPrinterPass(llvm::outs()))
 SCOP_PASS("polly-prune-unprofitable", PruneUnprofitablePass())
 SCOP_PASS("polly-opt-isl", IslScheduleOptimizerPass())
-SCOP_PASS("print<polly-opt-isl>", IslScheduleOptimizerPrinterPass(outs()))
+SCOP_PASS("print<polly-opt-isl>", IslScheduleOptimizerPrinterPass(llvm::outs()))
 SCOP_PASS("polly-dce", DeadCodeElimPass())
 #undef SCOP_PASS

polly/lib/Support/RegisterPasses.cpp

 #include "polly/ScheduleOptimizer.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
 #include "polly/Simplify.h"
 #include "polly/Support/DumpFunctionPass.h"
 #include "polly/Support/DumpModulePass.h"
 #include "llvm/Analysis/CFGPrinter.h"
 #include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
-using namespace llvm;
-using namespace polly;
+namespace cl = llvm::cl;
+
+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::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> PollyDetectOnly(
     "polly-only-scop-detection",
     cl::desc("Only run scop detection, but no other optimizations"),
#ifdef GPU_CODEGEN
                           ,
                       clEnumValN(TARGET_GPU, "gpu", "generate GPU code"),
                       clEnumValN(TARGET_HYBRID, "hybrid",
                                  "generate GPU code (preferably) or CPU code")
 #endif
                           ),
            cl::init(TARGET_CPU), cl::ZeroOrMore, cl::cat(PollyCategory));
 
-VectorizerChoice polly::PollyVectorizerChoice;
-static cl::opt<polly::VectorizerChoice, true> Vectorizer(
+VectorizerChoice PollyVectorizerChoice;
+
+static cl::opt<VectorizerChoice, true> Vectorizer(
     "polly-vectorizer", cl::desc("Select the vectorization strategy"),
     cl::values(
-        clEnumValN(polly::VECTORIZER_NONE, "none", "No Vectorization"),
-        clEnumValN(polly::VECTORIZER_POLLY, "polly",
-                   "Polly internal vectorizer"),
+        clEnumValN(VECTORIZER_NONE, "none", "No Vectorization"),
+        clEnumValN(VECTORIZER_POLLY, "polly", "Polly internal vectorizer"),
         clEnumValN(
-            polly::VECTORIZER_STRIPMINE, "stripmine",
+            VECTORIZER_STRIPMINE, "stripmine",
             "Strip-mine outer loops for the loop-vectorizer to trigger")),
-    cl::location(PollyVectorizerChoice), cl::init(polly::VECTORIZER_NONE),
+    cl::location(PollyVectorizerChoice), cl::init(VECTORIZER_NONE),
     cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> ImportJScop(
     "polly-import",
     cl::desc("Import the polyhedral description of the detected Scops"),
     cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> FullyIndexedStaticExpansion(
public:
   StaticInitializer() {
     llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
     polly::initializePollyPasses(Registry);
   }
 };
 static StaticInitializer InitializeEverything;
 } // end of anonymous namespace.
 
-namespace polly {
-void initializePollyPasses(PassRegistry &Registry) {
+void initializePollyPasses(llvm::PassRegistry &Registry) {
   initializeCodeGenerationPass(Registry);
 
 #ifdef GPU_CODEGEN
   initializePPCGCodeGenerationPass(Registry);
   initializeManagedMemoryRewritePassPass(Registry);
   LLVMInitializeNVPTXTarget();
   LLVMInitializeNVPTXTargetInfo();
   LLVMInitializeNVPTXTargetMC();
#ifdef GPU_CODEGEN
   if (Target == TARGET_HYBRID)
     PM.add(polly::createManagedMemoryRewritePassPass(GPUArchChoice,
                                                      GPURuntimeChoice));
 #endif
 
   // FIXME: This dummy ModulePass keeps some programs from miscompiling,
   // probably some not correctly preserved analyses. It acts as a barrier to
   // force all analysis results to be recomputed.
-  PM.add(createBarrierNoopPass());
+  PM.add(llvm::createBarrierNoopPass());
 
   if (DumpAfter)
     PM.add(polly::createDumpModuleWrapperPass("-after", true));
   for (auto &Filename : DumpAfterFile)
     PM.add(polly::createDumpModuleWrapperPass(Filename, false));
 
   if (CFGPrinter)
     PM.add(llvm::createCFGPrinterLegacyPassPass());
static void buildCommonPollyPipeline(FunctionPassManager &PM,
 
   if (PollyDetectOnly) {
     // Don't add more passes other than the ScopPassManager's detection passes.
     PM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
     return;
   }
 
   if (PollyViewer)
-    report_fatal_error("Option -polly-show not supported with NPM", false);
+    llvm::report_fatal_error("Option -polly-show not supported with NPM",
+                             false);
   if (PollyOnlyViewer)
-    report_fatal_error("Option -polly-show-only not supported with NPM", false);
+    llvm::report_fatal_error("Option -polly-show-only not supported with NPM",
+                             false);
   if (PollyPrinter)
-    report_fatal_error("Option -polly-dot not supported with NPM", false);
+    llvm::report_fatal_error("Option -polly-dot not supported with NPM", false);
   if (PollyOnlyPrinter)
-    report_fatal_error("Option -polly-dot-only not supported with NPM", false);
+    llvm::report_fatal_error("Option -polly-dot-only not supported with NPM",
+                             false);
   if (EnablePolyhedralInfo)
-    report_fatal_error(
+    llvm::report_fatal_error(
         "Option -polly-enable-polyhedralinfo not supported with NPM", false);
 
   if (EnableSimplify)
     SPM.addPass(SimplifyPass(0));
   if (EnableForwardOpTree)
     SPM.addPass(ForwardOpTreePass());
   if (EnableDeLICM)
     SPM.addPass(DeLICMPass());
   if (EnableSimplify)
     SPM.addPass(SimplifyPass(1));
 
   if (ImportJScop)
     SPM.addPass(JSONImportPass());
 
   if (DeadCodeElim)
     SPM.addPass(DeadCodeElimPass());
 
   if (FullyIndexedStaticExpansion)
-    report_fatal_error("Option -polly-enable-mse not supported with NPM",
+    llvm::report_fatal_error("Option -polly-enable-mse not supported with NPM",
                              false);
 
   if (EnablePruneUnprofitable)
     SPM.addPass(PruneUnprofitablePass());
 
   if (Target == TARGET_CPU || Target == TARGET_HYBRID) {
     switch (Optimizer) {
     case OPTIMIZER_NONE:
       break; /* Do nothing */
     case OPTIMIZER_ISL:
       SPM.addPass(IslScheduleOptimizerPass());
       break;
     }
   }
 
   if (ExportJScop)
-    report_fatal_error("Option -polly-export not supported with NPM", false);
+    llvm::report_fatal_error("Option -polly-export not supported with NPM",
+                             false);
 
   if (!EnableForOpt)
     return;
 
   if (Target == TARGET_CPU || Target == TARGET_HYBRID) {
     switch (CodeGeneration) {
     case CODEGEN_AST:
       SPM.addPass(
-          RequireAnalysisPass<IslAstAnalysis, Scop, ScopAnalysisManager,
-                              ScopStandardAnalysisResults &, SPMUpdater &>());
+          llvm::RequireAnalysisPass<IslAstAnalysis, Scop, ScopAnalysisManager,
+                                    ScopStandardAnalysisResults &,
+                                    SPMUpdater &>());
       break;
     case CODEGEN_FULL:
       SPM.addPass(CodeGenerationPass());
       break;
     case CODEGEN_NONE:
       break;
     }
   }
 #ifdef GPU_CODEGEN
   else
-    report_fatal_error("Option -polly-target=gpu not supported for NPM", false);
+    llvm::report_fatal_error("Option -polly-target=gpu not supported for NPM",
+                             false);
 #endif
 
 #ifdef GPU_CODEGEN
   if (Target == TARGET_HYBRID)
-    report_fatal_error("Option -polly-target=hybrid not supported for NPM",
-                       false);
+    llvm::report_fatal_error(
+        "Option -polly-target=hybrid not supported for NPM", false);
 #endif
 
   PM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
   PM.addPass(PB.buildFunctionSimplificationPipeline(
-      Level, ThinOrFullLTOPhase::None)); // Cleanup
+      Level, llvm::ThinOrFullLTOPhase::None)); // Cleanup
 
   if (CFGPrinter)
     PM.addPass(llvm::CFGPrinterPass());
 }
 
-static void buildEarlyPollyPipeline(ModulePassManager &MPM,
-                                    OptimizationLevel Level) {
+static void buildEarlyPollyPipeline(llvm::ModulePassManager &MPM,
+                                    llvm::OptimizationLevel Level) {
   bool EnableForOpt =
       shouldEnablePollyForOptimization() && Level.isOptimizingForSpeed();
   if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
     return;
 
   FunctionPassManager FPM = buildCanonicalicationPassesForNPM(MPM, Level);
 
   if (DumpBefore || !DumpBeforeFile.empty()) {
static void buildEarlyPollyPipeline(llvm::ModulePassManager &MPM,
 
   if (DumpAfter)
     MPM.addPass(DumpModulePass("-after", true));
   for (auto &Filename : DumpAfterFile)
     MPM.addPass(DumpModulePass(Filename, false));
 }
 
 static void buildLatePollyPipeline(FunctionPassManager &PM,
-                                   OptimizationLevel Level) {
+                                   llvm::OptimizationLevel Level) {
   bool EnableForOpt =
       shouldEnablePollyForOptimization() && Level.isOptimizingForSpeed();
   if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
     return;
 
   if (DumpBefore)
     PM.addPass(DumpFunctionPass("-before"));
   if (!DumpBeforeFile.empty())
-    report_fatal_error("Option -polly-dump-before-file at -polly-position=late "
-                       "not supported with NPM",
-                       false);
+    llvm::report_fatal_error(
+        "Option -polly-dump-before-file at -polly-position=late "
 
   buildCommonPollyPipeline(PM, Level, EnableForOpt);
 
   if (DumpAfter)
     PM.addPass(DumpFunctionPass("-after"));
   if (!DumpAfterFile.empty())
-    report_fatal_error("Option -polly-dump-after-file at -polly-position=late "
-                       "not supported with NPM",
-                       false);
+    llvm::report_fatal_error(
+        "Option -polly-dump-after-file at -polly-position=late "
 }
 
 /// Register Polly to be available as an optimizer
 ///
 ///
 /// We can currently run Polly at three different points int the pass manager.
 /// a) very early, b) after the canonicalizing loop transformations and c) right
 /// before the vectorizer.

 #include "PollyPasses.def"
 
   FAM.registerPass([&FAM, PIC] { return createScopAnalyses(FAM, PIC); });
 }
 
 static bool
 parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
                       ArrayRef<PassBuilder::PipelineElement> Pipeline) {
-  if (parseAnalysisUtilityPasses<OwningScopAnalysisManagerFunctionProxy>(
+  if (llvm::parseAnalysisUtilityPasses<OwningScopAnalysisManagerFunctionProxy>(
           "polly-scop-analyses", Name, FPM))
     return true;
 
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
-  if (parseAnalysisUtilityPasses<                                              \
+  if (llvm::parseAnalysisUtilityPasses<                                        \
           std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name,      \
                                                               FPM))            \
     return true;
 
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
     FPM.addPass(CREATE_PASS);                                                  \
     return true;                                                               \
   }
 
 #include "PollyPasses.def"
   return false;
 }
 
 static bool parseScopPass(StringRef Name, ScopPassManager &SPM,
                           PassInstrumentationCallbacks *PIC) {
 #define SCOP_ANALYSIS(NAME, CREATE_PASS)                                       \
-  if (parseAnalysisUtilityPasses<                                              \
+  if (llvm::parseAnalysisUtilityPasses<                                        \
           std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name,      \
                                                               SPM))            \
     return true;
 
 #define SCOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
     SPM.addPass(CREATE_PASS);                                                  \
     return true;                                                               \
if (Name == NAME)                                                            \
     return true;
 
 #include "PollyPasses.def"
 
   return false;
 }
 
 static bool
-parseTopLevelPipeline(ModulePassManager &MPM, PassInstrumentationCallbacks *PIC,
+parseTopLevelPipeline(llvm::ModulePassManager &MPM,
+                      PassInstrumentationCallbacks *PIC,
                       ArrayRef<PassBuilder::PipelineElement> Pipeline) {
   std::vector<PassBuilder::PipelineElement> FullPipeline;
   StringRef FirstName = Pipeline.front().Name;
 
   if (!isScopPassName(FirstName))
     return false;
 
   FunctionPassManager FPM;
void registerPollyPasses(PassBuilder &PB) {
   });
   PB.registerPipelineParsingCallback(parseFunctionPipeline);
   PB.registerPipelineParsingCallback(
       [PIC](StringRef Name, FunctionPassManager &FPM,
             ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
         return parseScopPipeline(Name, FPM, PIC, Pipeline);
       });
   PB.registerParseTopLevelPipelineCallback(
-      [PIC](ModulePassManager &MPM,
+      [PIC](llvm::ModulePassManager &MPM,
             ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
         return parseTopLevelPipeline(MPM, PIC, Pipeline);
       });
 
   switch (PassPosition) {
   case POSITION_EARLY:
     PB.registerPipelineStartEPCallback(buildEarlyPollyPipeline);
     break;
   case POSITION_AFTER_LOOPOPT:
-    report_fatal_error(
+    llvm::report_fatal_error(
         "Option -polly-position=after-loopopt not supported with NPM", false);
     break;
   case POSITION_BEFORE_VECTORIZER:
     PB.registerVectorizerStartEPCallback(buildLatePollyPipeline);
     break;
   }
 }
 } // namespace polly
 
 llvm::PassPluginLibraryInfo getPollyPluginInfo() {
   return {LLVM_PLUGIN_API_VERSION, "Polly", LLVM_VERSION_STRING,
           polly::registerPollyPasses};
 }