[Polly] Add -polly-dump-module pass.

[Meinersbur]

Summary

This pass allows writing the LLVM-IR just before and after the Polly
passes to a file.

Dumping the IR before Polly helps reproducing bugs that occur in code
generated by clang. It is the only reliable way to get the IR that
triggers a bug. The alternative is to emit the IR with

clang -c -emit-llvm -S -o dump.ll

then pass it through all optimization passes

opt dump.ll -basicaa -sroa ... -S -o optdump.ll

to then reproduce the error with

opt optdump.ll -polly-opt-isl -polly-codegen -analyze

However, the IR is not the same. -O3 uses a PassBuilder than creates passes
with different parameters than the default.

Dumping the IR after Polly is useful to compare a miscompilation with
a known-good configuration.

[grosser]

Hi Michael,

this looks good to me.

polly/trunk/include/polly/LinkAllPasses.h

 // like opt and bugpoint that need this functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_LINKALLPASSES_H
 #define POLLY_LINKALLPASSES_H
 
 #include "polly/Config/config.h"
+#include "polly/Support/DumpModulePass.h"
+#include "llvm/ADT/StringRef.h"
 #include <cstdlib>
 
 namespace llvm {
 class Pass;
 class PassInfo;
 class PassRegistry;
 class RegionPass;
 } // namespace llvm
PollyForcePassLinking() {
     polly::createIslAstInfoPass();
     polly::createCodeGenerationPass();
 #ifdef GPU_CODEGEN
     polly::createPPCGCodeGenerationPass();
 #endif
     polly::createIslScheduleOptimizerPass();
     polly::createFlattenSchedulePass();
     polly::createDeLICMPass();
+    polly::createDumpModulePass("", true);
   }
 } PollyForcePassLinking; // Force link by creating a global definition.
 } // namespace
 
 namespace llvm {
 class PassRegistry;
 void initializeCodePreparationPass(llvm::PassRegistry &);
 void initializeDeadCodeElimPass(llvm::PassRegistry &);

polly/trunk/include/polly/Support/DumpModulePass.h

+//===------ DumpModulePass.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Write a module to a file.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef POLLY_SUPPORT_DUMPMODULEPASS_H
+#define POLLY_SUPPORT_DUMPMODULEPASS_H
+
+namespace llvm {
+class StringRef;
+class ModulePass;
+} // namespace llvm
+
+namespace polly {
+/// Create a pass that prints the module into a file.
+///
+/// The meaning of @p Filename depends on @p IsSuffix. If IsSuffix==false, then
+/// the module is written to the @p Filename. If it is true, the filename is
+/// generated from the module's name, @p Filename with an '.ll' extension.
+///
+/// The intent of IsSuffix is to avoid the file being overwritten when
+/// processing multiple modules and/or with multiple dump passes in the
+/// pipeline.
+llvm::ModulePass *createDumpModulePass(llvm::StringRef Filename, bool IsSuffix);
+} // namespace polly
+
+namespace llvm {
+class PassRegistry;
+void initializeDumpModulePass(llvm::PassRegistry &);
+} // namespace llvm
+
+#endif /* POLLY_SUPPORT_DUMPMODULEPASS_H */

polly/trunk/lib/CMakeLists.txt

add_polly_library(Polly
   Exchange/JSONExporter.cpp
   Support/GICHelper.cpp
   Support/SCEVAffinator.cpp
   Support/SCEVValidator.cpp
   Support/RegisterPasses.cpp
   Support/ScopHelper.cpp
   Support/ScopLocation.cpp
   Support/ISLTools.cpp
+  Support/DumpModulePass.cpp
   ${POLLY_JSON_FILES}
   Transform/Canonicalization.cpp
   Transform/CodePreparation.cpp
   Transform/DeadCodeElimination.cpp
   Transform/ScheduleOptimizer.cpp
   Transform/FlattenSchedule.cpp
   Transform/FlattenAlgo.cpp
   Transform/DeLICM.cpp

polly/trunk/lib/Support/DumpModulePass.cpp

+//===------ DumpModulePass.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Write a module to a file.
+//
+//===----------------------------------------------------------------------===//
+
+#include "polly/Support/DumpModulePass.h"
+
+#include "polly/Options.h"
+#include "llvm/IR/LegacyPassManagers.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include <string.h>
+#define DEBUG_TYPE "polly-dump-module"
+
+using namespace llvm;
+using namespace polly;
+
+namespace {
+
+class DumpModule : public ModulePass {
+private:
+  DumpModule(const DumpModule &) = delete;
+  const DumpModule &operator=(const DumpModule &) = delete;
+
+  std::string Filename;
+  bool IsSuffix;
+
+public:
+  static char ID;
+
+  /// This constructor is used e.g. if using opt -polly-dump-module.
+  ///
+  /// Provide a default suffix to not overwrite the original file.
+  explicit DumpModule() : ModulePass(ID), Filename("-dump"), IsSuffix(true) {}
+
+  explicit DumpModule(llvm::StringRef Filename, bool IsSuffix)
+      : ModulePass(ID), Filename(Filename), IsSuffix(IsSuffix) {}
+
+  /// @name ModulePass interface
+  //@{
+  virtual void getAnalysisUsage(llvm::AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+
+  virtual bool runOnModule(llvm::Module &M) override {
+    std::string Dumpfile;
+    if (IsSuffix) {
+      auto ModuleName = M.getName();
+      auto Stem = sys::path::stem(ModuleName);
+      Dumpfile = (Twine(Stem) + Filename + ".ll").str();
+    } else {
+      Dumpfile = Filename;
+    }
+    DEBUG(dbgs() << "Dumping module to " << Dumpfile << '\n');
+
+    std::unique_ptr<tool_output_file> Out;
+    std::error_code EC;
+    Out.reset(new tool_output_file(Dumpfile, EC, sys::fs::F_None));
+    if (EC) {
+      errs() << EC.message() << '\n';
+      return false;
+    }
+
+    M.print(Out->os(), nullptr);
+    Out->keep();
+
+    return false;
+  }
+  //@}
+};
+
+char DumpModule::ID;
+} // namespace
+
+ModulePass *polly::createDumpModulePass(llvm::StringRef Filename,
+                                        bool IsSuffix) {
+  return new DumpModule(Filename, IsSuffix);
+}
+
+INITIALIZE_PASS_BEGIN(DumpModule, "polly-dump-module", "Polly - Dump Module",
+                      false, false)
+INITIALIZE_PASS_END(DumpModule, "polly-dump-module", "Polly - Dump Module",
+                    false, false)

polly/trunk/lib/Support/RegisterPasses.cpp

 #include "polly/DeLICM.h"
 #include "polly/DependenceInfo.h"
 #include "polly/FlattenSchedule.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/PolyhedralInfo.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
+#include "polly/Support/DumpModulePass.h"
 #include "llvm/Analysis/CFGPrinter.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Vectorize.h"
 
 using namespace llvm;
CFGPrinter("polly-view-cfg",
                cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<bool>
     EnablePolyhedralInfo("polly-enable-polyhedralinfo",
                          cl::desc("Enable polyhedral interface of Polly"),
                          cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<bool>
+    DumpBefore("polly-dump-before",
+               cl::desc("Dump module before Polly transformations into a file "
+                        "suffixed with \"-before\""),
+               cl::init(false), cl::cat(PollyCategory));
+
+static cl::list<std::string> DumpBeforeFile(
+    "polly-dump-before-file",
+    cl::desc("Dump module before Polly transformations to the given file"),
+    cl::cat(PollyCategory));
+
+static cl::opt<bool>
+    DumpAfter("polly-dump-after",
+              cl::desc("Dump module after Polly transformations into a file "
+                       "suffixed with \"-after\""),
+              cl::init(false), cl::cat(PollyCategory));
+
+static cl::list<std::string> DumpAfterFile(
+    "polly-dump-after-file",
+    cl::desc("Dump module after Polly transformations to the given file"),
+    cl::ZeroOrMore, cl::cat(PollyCategory));
+
+static cl::opt<bool>
     EnableDeLICM("polly-enable-delicm",
                  cl::desc("Eliminate scalar loop carried dependences"),
                  cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 namespace polly {
 void initializePollyPasses(PassRegistry &Registry) {
   initializeCodeGenerationPass(Registry);
 
#endif
   initializePollyCanonicalizePass(Registry);
   initializePolyhedralInfoPass(Registry);
   initializeScopDetectionPass(Registry);
   initializeScopInfoRegionPassPass(Registry);
   initializeScopInfoWrapperPassPass(Registry);
   initializeCodegenCleanupPass(Registry);
   initializeFlattenSchedulePass(Registry);
   initializeDeLICMPass(Registry);
+  initializeDumpModulePass(Registry);
 }
 
 /// Register Polly passes such that they form a polyhedral optimizer.
 ///
 /// The individual Polly passes are registered in the pass manager such that
 /// they form a full polyhedral optimizer. The flow of the optimizer starts with
 /// a set of preparing transformations that canonicalize the LLVM-IR such that
 /// the LLVM-IR is easier for us to understand and to optimizes. On the

 /// As scheduling optimizer we support the isl scheduling optimizer
 /// (http://freecode.com/projects/isl).
 /// It is also possible to run Polly with no optimizer. This mode is mainly
 /// provided to analyze the run and compile time changes caused by the
 /// scheduling optimizer.
 ///
 /// Polly supports the isl internal code generator.
 void registerPollyPasses(llvm::legacy::PassManagerBase &PM) {
+  if (DumpBefore)
+    PM.add(polly::createDumpModulePass("-before", true));
+  for (auto &Filename : DumpBeforeFile)
+    PM.add(polly::createDumpModulePass(Filename, false));
+
   PM.add(polly::createScopDetectionPass());
 
   if (PollyDetectOnly)
     return;
 
   if (PollyViewer)
     PM.add(polly::createDOTViewerPass());
   if (PollyOnlyViewer)
#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());
 
+  if (DumpAfter)
+    PM.add(polly::createDumpModulePass("-after", true));
+  for (auto &Filename : DumpAfterFile)
+    PM.add(polly::createDumpModulePass(Filename, false));
+
   if (CFGPrinter)
     PM.add(llvm::createCFGPrinterLegacyPassPass());
 
   if (Target == TARGET_GPU) {
     // Invariant load hoisting not yet supported by GPU code generation.
     PollyInvariantLoadHoisting = false;
   }
 }