[JSON][PM] Port json import/export over to new pm

[philip.pfaffe]

Summary

I pulled out all functionality into static functions, and use those both
in the legacy passes and in the new ones. There is one functional
change: Before, if we fail to parse a jscop file, this will be reported
as an error and importing is aborted. However, this isn't actually
strong enough, since although the import is aborted, the scop has
already been modified and is very likely broken. Instead, make this a
hard failure and throw an LLVM error. This new behaviour requires small
changes to the tests for the legacy pass, namely using not.

[Meinersbur]

There are multiple changes in this patch:

• Fixing some broken regression tests
• Add import/export to new PM
• Hard error on jscop import fail (cool!)
• Make some private methods of JSONImporter free functions.

I'd wish for a clearer commit message about these changes, if not even committing separately.

lib/Exchange/JSONExporter.cpp

212

[Style] Make static?

391–392

unrelated?

434–435

unrelated?

lib/Exchange/JSONExporter.cpp

 //===-- JSONExporter.cpp  - Export Scops as JSON  -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Export the Scops build by ScopInfo pass as a JSON file.
 //
 //===----------------------------------------------------------------------===//
 
+#include "polly/JSONExporter.h"
 #include "polly/DependenceInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
 #include "polly/ScopPass.h"
 #include "polly/Support/ScopLocation.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/RegionInfo.h"
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;
   explicit JSONExporter() : ScopPass(ID) {}
 
-  std::string getFileName(Scop &S) const;
-  Json::Value getJSON(Scop &S) const;
-
   /// Export the SCoP @p S to a JSON file.
   bool runOnScop(Scop &S) override;
 
   /// Print the SCoP @p S as it is exported.
   void printScop(raw_ostream &OS, Scop &S) const override;
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 
 struct JSONImporter : public ScopPass {
   static char ID;
   std::vector<std::string> NewAccessStrings;
   explicit JSONImporter() : ScopPass(ID) {}
-
-  /// Import a new context from JScop.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing the new schedule.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importContext(Scop &S, Json::Value &JScop);
-
-  /// Import a new schedule from JScop.
-  ///
-  /// ... and verify that the new schedule does preserve existing data
-  /// dependences.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing the new schedule.
-  /// @param D The data dependences of the @p S.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importSchedule(Scop &S, Json::Value &JScop, const Dependences &D);
-
-  /// Import new arrays from JScop.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing new arrays.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importArrays(Scop &S, Json::Value &JScop);
-
-  /// Import new memory accesses from JScop.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing the new schedule.
-  /// @param DL The data layout to assume.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importAccesses(Scop &S, Json::Value &JScop, const DataLayout &DL);
-
-  std::string getFileName(Scop &S) const;
-
   /// Import new access functions for SCoP @p S from a JSON file.
   bool runOnScop(Scop &S) override;
 
   /// Print the SCoP @p S and the imported access functions.
   void printScop(raw_ostream &OS, Scop &S) const override;
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 } // namespace
 
-char JSONExporter::ID = 0;
-std::string JSONExporter::getFileName(Scop &S) const {
+static std::string getFileName(Scop &S, StringRef Suffix = "") {
   std::string FunctionName = S.getFunction().getName();
   std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
+
+  if (Suffix != "")
+    FileName += "." + Suffix.str();
+
   return FileName;
 }
 
-void JSONExporter::printScop(raw_ostream &OS, Scop &S) const { OS << S; }
-
 /// Export all arrays from the Scop.
 ///
 /// @param S The Scop containing the arrays.
 ///
 /// @returns Json::Value containing the arrays.
-Json::Value exportArrays(const Scop &S) {
+static Json::Value exportArrays(const Scop &S) {
   Json::Value Arrays;
   std::string Buffer;
   llvm::raw_string_ostream RawStringOstream(Buffer);
 
   for (auto &SAI : S.arrays()) {
     if (!SAI->isArrayKind())
       continue;
 
for (auto &SAI : S.arrays()) {
     SAI->getElementType()->print(RawStringOstream);
     Array["type"] = RawStringOstream.str();
     Buffer.clear();
     Arrays.append(Array);
   }
   return Arrays;
 }
 
-Json::Value JSONExporter::getJSON(Scop &S) const {
+static Json::Value getJSON(Scop &S) {
   Json::Value root;
   unsigned LineBegin, LineEnd;
   std::string FileName;
 
   getDebugLocation(&S.getRegion(), LineBegin, LineEnd, FileName);
   std::string Location;
   if (LineBegin != (unsigned)-1)
     Location = FileName + ":" + std::to_string(LineBegin) + "-" +
for (ScopStmt &Stmt : S) {
     }
 
     root["statements"].append(statement);
   }
 
   return root;
 }
 
-bool JSONExporter::runOnScop(Scop &S) {
+static void exportScop(Scop &S) {
   std::string FileName = ImportDir + "/" + getFileName(S);
 
   Json::Value jscop = getJSON(S);
   Json::StyledWriter writer;
   std::string fileContent = writer.write(jscop);
 
   // Write to file.
   std::error_code EC;
   tool_output_file F(FileName, EC, llvm::sys::fs::F_Text);
 
   std::string FunctionName = S.getFunction().getName();
   errs() << "Writing JScop '" << S.getNameStr() << "' in function '"
          << FunctionName << "' to '" << FileName << "'.\n";
 
   if (!EC) {
     F.os() << fileContent;
     F.os().close();
     if (!F.os().has_error()) {
       errs() << "\n";
       F.keep();
-      return false;
+      return;
     }
   }
 
   errs() << "  error opening file for writing!\n";
   F.os().clear_error();
-
-  return false;
-}
-
-void JSONExporter::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.setPreservesAll();
-  AU.addRequired<ScopInfoRegionPass>();
-}
-
-Pass *polly::createJSONExporterPass() { return new JSONExporter(); }
-
-char JSONImporter::ID = 0;
-std::string JSONImporter::getFileName(Scop &S) const {
-  std::string FunctionName = S.getFunction().getName();
-  std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
-
-  if (ImportPostfix != "")
-    FileName += "." + ImportPostfix;
-
-  return FileName;
-}
-
-void JSONImporter::printScop(raw_ostream &OS, Scop &S) const {
-  OS << S;
-  for (std::vector<std::string>::const_iterator I = NewAccessStrings.begin(),
-                                                E = NewAccessStrings.end();
-       I != E; I++)
-    OS << "New access function '" << *I << "' detected in JSCOP file\n";
 }
 
 typedef Dependences::StatementToIslMapTy StatementToIslMapTy;
 
-bool JSONImporter::importContext(Scop &S, Json::Value &JScop) {
+/// Import a new context from JScop.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing the new schedule.
+///
+/// @returns True if the import succeeded, otherwise False.
+bool importContext(Scop &S, Json::Value &JScop) {
   isl_set *OldContext = S.getContext().release();
 
   // Check if key 'context' is present.
   if (!JScop.isMember("context")) {
     errs() << "JScop file has no key named 'context'.\n";
     isl_set_free(OldContext);
     return false;
   }
for (unsigned i = 0; i < OldContextDim; i++) {
     NewContext = isl_set_set_dim_id(NewContext, isl_dim_param, i, Id);
   }
 
   isl_set_free(OldContext);
   S.setContext(NewContext);
   return true;
 }
 
-bool JSONImporter::importSchedule(Scop &S, Json::Value &JScop,
-                                  const Dependences &D) {
+/// Import a new schedule from JScop.
+///
+/// ... and verify that the new schedule does preserve existing data
+/// dependences.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing the new schedule.
+/// @param D The data dependences of the @p S.
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool importSchedule(Scop &S, Json::Value &JScop, const Dependences &D) {
   StatementToIslMapTy NewSchedule;
 
   // Check if key 'statements' is present.
   if (!JScop.isMember("statements")) {
     errs() << "JScop file has no key name 'statements'.\n";
     return false;
   }
 
else
           isl_union_map_add_map(ScheduleMap, Stmt.getSchedule().release());
   }
 
   S.setSchedule(ScheduleMap);
 
   return true;
 }
 
-bool JSONImporter::importAccesses(Scop &S, Json::Value &JScop,
-                                  const DataLayout &DL) {
+/// Import new memory accesses from JScop.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing the new schedule.
+/// @param DL The data layout to assume.
+/// @param NewAccessStrings optionally record the imported access strings
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool
+importAccesses(Scop &S, Json::Value &JScop, const DataLayout &DL,
+               std::vector<std::string> *NewAccessStrings = nullptr) {
   int StatementIdx = 0;
 
   // Check if key 'statements' is present.
   if (!JScop.isMember("statements")) {
     errs() << "JScop file has no key name 'statements'.\n";
     return false;
   }
   Json::Value statements = JScop["statements"];
for (ScopStmt &Stmt : S) {
     // Check if key 'accesses' is present.
     if (!statements[StatementIdx].isMember("accesses")) {
       errs()
           << "Statement from JScop file has no key name 'accesses' for index "
           << StatementIdx << ".\n";
       return false;
     }
 
-    // Check whether the number of indices equals the number of memory accesses
+    // Check whether the number of indices equals the number of memory
+    // accesses
     if (Stmt.size() != statements[StatementIdx]["accesses"].size()) {
       errs() << "The number of memory accesses in the JSop file and the number "
                 "of memory accesses differ for index "
              << StatementIdx << ".\n";
       return false;
     }
 
     for (MemoryAccess *MA : Stmt) {
for (MemoryAccess *MA : Stmt) {
         isl_map_free(NewAccessMap);
         return false;
       }
 
       isl_id *NewOutId;
 
       // If the NewAccessMap has zero dimensions, it is the scalar access; it
       // must be the same as before.
-      // If it has at least one dimension, it's an array access; search for its
-      // ScopArrayInfo.
+      // If it has at least one dimension, it's an array access; search for
+      // its ScopArrayInfo.
       if (isl_map_dim(NewAccessMap, isl_dim_out) >= 1) {
         NewOutId = isl_map_get_tuple_id(NewAccessMap, isl_dim_out);
         auto *SAI = S.getArrayInfoByName(isl_id_get_name(NewOutId));
         isl_id *OutId = isl_map_get_tuple_id(CurrentAccessMap, isl_dim_out);
         auto *OutSAI = ScopArrayInfo::getFromId(isl::manage(OutId));
         if (!SAI || SAI->getElementType() != OutSAI->getElementType()) {
           errs() << "JScop file contains access function with undeclared "
                     "ScopArrayInfo\n";
for (MemoryAccess *MA : Stmt) {
       }
 
       isl_set_free(CurrentAccessDomain);
       isl_set_free(NewAccessDomain);
 
       if (!isl_map_is_equal(NewAccessMap, CurrentAccessMap)) {
         // Statistics.
         ++NewAccessMapFound;
-        NewAccessStrings.push_back(Accesses.asCString());
+        if (NewAccessStrings)
+          NewAccessStrings->push_back(Accesses.asCString());
         MA->setNewAccessRelation(isl::manage(NewAccessMap));
       } else {
         isl_map_free(NewAccessMap);
       }
       isl_map_free(CurrentAccessMap);
       MemoryAccessIdx++;
     }
     StatementIdx++;
   }
 
   return true;
 }
 
 /// Check whether @p SAI and @p Array represent the same array.
-bool areArraysEqual(ScopArrayInfo *SAI, Json::Value Array) {
+static bool areArraysEqual(ScopArrayInfo *SAI, Json::Value Array) {
   std::string Buffer;
   llvm::raw_string_ostream RawStringOstream(Buffer);
 
   // Check if key 'type' is present.
   if (!Array.isMember("type")) {
     errs() << "Array has no key 'type'.\n";
     return false;
   }

 }
 
 /// Get the accepted primitive type from its textual representation
 ///        @p TypeTextRepresentation.
 ///
 /// @param TypeTextRepresentation The textual representation of the type.
 /// @return The pointer to the primitive type, if this type is accepted
 ///         or nullptr otherwise.
-Type *parseTextType(const std::string &TypeTextRepresentation,
+static Type *parseTextType(const std::string &TypeTextRepresentation,
                            LLVMContext &LLVMContext) {
   std::map<std::string, Type *> MapStrToType = {
       {"void", Type::getVoidTy(LLVMContext)},
       {"half", Type::getHalfTy(LLVMContext)},
       {"float", Type::getFloatTy(LLVMContext)},
       {"double", Type::getDoubleTy(LLVMContext)},
       {"x86_fp80", Type::getX86_FP80Ty(LLVMContext)},
       {"fp128", Type::getFP128Ty(LLVMContext)},
       {"ppc_fp128", Type::getPPC_FP128Ty(LLVMContext)},
       {"i1", Type::getInt1Ty(LLVMContext)},
       {"i8", Type::getInt8Ty(LLVMContext)},
       {"i16", Type::getInt16Ty(LLVMContext)},
       {"i32", Type::getInt32Ty(LLVMContext)},
       {"i64", Type::getInt64Ty(LLVMContext)},
       {"i128", Type::getInt128Ty(LLVMContext)}};
 
   auto It = MapStrToType.find(TypeTextRepresentation);
   if (It != MapStrToType.end())
     return It->second;
 
   errs() << "Textual representation can not be parsed: "
          << TypeTextRepresentation << "\n";
   return nullptr;
 }
 
-bool JSONImporter::importArrays(Scop &S, Json::Value &JScop) {
+/// Import new arrays from JScop.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing new arrays.
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool importArrays(Scop &S, Json::Value &JScop) {
   Json::Value Arrays = JScop["arrays"];
   if (Arrays.size() == 0)
     return true;
 
   unsigned ArrayIdx = 0;
   for (auto &SAI : S.arrays()) {
     if (!SAI->isArrayKind())
       continue;
for (; ArrayIdx < Arrays.size(); ArrayIdx++) {
     if (Array.isMember("allocation")) {
       NewSAI->setIsOnHeap(Array["allocation"].asString() == "heap");
     }
   }
 
   return true;
 }
 
-bool JSONImporter::runOnScop(Scop &S) {
-  const Dependences &D =
-      getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
-  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
-
-  std::string FileName = ImportDir + "/" + getFileName(S);
+/// Import a Scop from a JSCOP file
+/// @param S The scop to be modified
+/// @param D Dependence Info
+/// @param DL The DataLayout of the function
+/// @param NewAccessStrings Optionally record the imported access strings
+///
+/// @returns true on success, false otherwise. Beware that if this returns
+/// false, the Scop may still have been modified. In this case the Scop contains
+/// invalid information.
+static bool importScop(Scop &S, const Dependences &D, const DataLayout &DL,
+                       std::vector<std::string> *NewAccessStrings = nullptr) {
+  std::string FileName = ImportDir + "/" + getFileName(S, ImportPostfix);
 
   std::string FunctionName = S.getFunction().getName();
   errs() << "Reading JScop '" << S.getNameStr() << "' in function '"
          << FunctionName << "' from '" << FileName << "'.\n";
   ErrorOr<std::unique_ptr<MemoryBuffer>> result =
       MemoryBuffer::getFile(FileName);
   std::error_code ec = result.getError();
 
static bool importScop(Scop &S, const Dependences &D, const DataLayout &DL,
   if (!Success)
     return false;
 
   Success = importArrays(S, jscop);
 
   if (!Success)
     return false;
 
-  Success = importAccesses(S, jscop, DL);
+  Success = importAccesses(S, jscop, DL, NewAccessStrings);
 
   if (!Success)
     return false;
+  return true;
+}
+
+char JSONExporter::ID = 0;
+void JSONExporter::printScop(raw_ostream &OS, Scop &S) const { OS << S; }
+
+bool JSONExporter::runOnScop(Scop &S) {
+  exportScop(S);
+  return false;
+}
+
+void JSONExporter::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
+  AU.addRequired<ScopInfoRegionPass>();
+}
 
+Pass *polly::createJSONExporterPass() { return new JSONExporter(); }
+
+PreservedAnalyses JSONExportPass::run(Scop &S, ScopAnalysisManager &SAM,
+                                      ScopStandardAnalysisResults &SAR,
+                                      SPMUpdater &) {
+  exportScop(S);
+  return PreservedAnalyses::all();
+}
+
+char JSONImporter::ID = 0;
+
+void JSONImporter::printScop(raw_ostream &OS, Scop &S) const {
+  OS << S;
+  for (std::vector<std::string>::const_iterator I = NewAccessStrings.begin(),
+                                                E = NewAccessStrings.end();
+       I != E; I++)
+    OS << "New access function '" << *I << "' detected in JSCOP file\n";
+}
+
+bool JSONImporter::runOnScop(Scop &S) {
+  const Dependences &D =
+      getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
+  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
+  if (!importScop(S, D, DL, &NewAccessStrings))
+    report_fatal_error("Tried to import a malformed jscop file.");
   return false;
 }
 
 void JSONImporter::getAnalysisUsage(AnalysisUsage &AU) const {
   ScopPass::getAnalysisUsage(AU);
   AU.addRequired<DependenceInfo>();
 }
 
 Pass *polly::createJSONImporterPass() { return new JSONImporter(); }
 
+PreservedAnalyses JSONImportPass::run(Scop &S, ScopAnalysisManager &SAM,
+                                      ScopStandardAnalysisResults &SAR,
+                                      SPMUpdater &) {
+  const Dependences &D =
+      SAM.getResult<DependenceAnalysis>(S, SAR).getDependences(
+          Dependences::AL_Statement);
+  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
+
+  if (!importScop(S, D, DL))
+    report_fatal_error("Tried to import a malformed jscop file.");
+
+  // This invalidates all analyses on Scop.
+  PreservedAnalyses PA;
+  PA.preserveSet<AllAnalysesOn<Module>>();
+  PA.preserveSet<AllAnalysesOn<Function>>();
+  PA.preserveSet<AllAnalysesOn<Loop>>();
+  return PA;
+}
+
 INITIALIZE_PASS_BEGIN(JSONExporter, "polly-export-jscop",
                       "Polly - Export Scops as JSON"
                       " (Writes a .jscop file for each Scop)",
                       false, false);
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo)
 INITIALIZE_PASS_END(JSONExporter, "polly-export-jscop",
                     "Polly - Export Scops as JSON"
                     " (Writes a .jscop file for each Scop)",

lib/Support/PollyPasses.def

 #endif
 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("polly-codegen", CodeGenerationPass())
 #undef SCOP_PASS

lib/Support/RegisterPasses.cpp

 #include "polly/CodeGen/CodegenCleanup.h"
 #include "polly/CodeGen/IslAst.h"
 #include "polly/CodeGen/PPCGCodeGeneration.h"
 #include "polly/CodePreparation.h"
 #include "polly/DeLICM.h"
 #include "polly/DependenceInfo.h"
 #include "polly/FlattenSchedule.h"
 #include "polly/ForwardOpTree.h"
+#include "polly/JSONExporter.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/PolyhedralInfo.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
 #include "polly/Simplify.h"
 #include "polly/Support/DumpModulePass.h"
 #include "llvm/Analysis/CFGPrinter.h"
static void buildDefaultPollyPipeline(FunctionPassManager &PM,
 
   assert(!PollyViewer && "This option is not implemented");
   assert(!PollyOnlyViewer && "This option is not implemented");
   assert(!PollyPrinter && "This option is not implemented");
   assert(!PollyOnlyPrinter && "This option is not implemented");
   assert(!EnablePolyhedralInfo && "This option is not implemented");
   assert(!EnableDeLICM && "This option is not implemented");
   assert(!EnableSimplify && "This option is not implemented");
-  assert(!ImportJScop && "This option is not implemented");
+  if (ImportJScop)
+    SPM.addPass(JSONImportPass());
   assert(!DeadCodeElim && "This option is not implemented");
   assert(!EnablePruneUnprofitable && "This option is not implemented");
   if (Target == TARGET_CPU || Target == TARGET_HYBRID)
     switch (Optimizer) {
     case OPTIMIZER_NONE:
       break; /* Do nothing */
     case OPTIMIZER_ISL:
       llvm_unreachable("ISL optimizer is not implemented");

test/Isl/CodeGen/MemAccess/bad_alignment.ll

-; RUN: opt %loadPolly -polly-import-jscop -analyze 2>&1 < %s | FileCheck %s
+; RUN: not opt %loadPolly -polly-import-jscop -analyze 2>&1 < %s | FileCheck %s
 ;
 ; Check that we do not allow to access elements not accessed before because the
 ; alignment information would become invalid.
 ;
 ; CHECK: JScop file changes the accessed memory
 ;
 ;    void bad_alignment(int *A) {
 ;      for (int i = 0; i < 1024; i += 2)

test/JSONExporter/ImportAccesses/ImportAccesses-Bad-relation.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The access was not parsed successfully by ISL.
 ;
 ; Verify that the JSONImporter checks if the relation is valid.
 ;
 ;    void ia6(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-No-accesses-key.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: Statement from JScop file has no key name 'accesses' for index 1.
 ;
 ; Verify that the JSONImporter checks if there is a key name "accesses" for each statement.
 ;
 ;    void ia3(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-Not-enough-MemAcc.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The number of memory accesses in the JSop file and the number of memory accesses differ for index 0.
 ;
 ; Verify that the JSONImporter checks if there is the correct number of memory accesses.
 ;
 ;    void ia4(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-Not-enough-statements.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The number of indices and the number of statements differ.
 ;
 ; Verify that the JSONImporter checks if the number of indices and the number of statements differ.
 ;
 ;    void ia2(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-Relation-mispelled.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: Memory access number 0 has no key name 'relation' for statement number 1.
 ;
 ; Verify that the JSONImporter checks if there is a key name 'relation' for each MemAcc.
 ;
 ;    void ia5(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-Statements-mispelled.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: JScop file has no key name 'statements'.
 ;
 ; Verify that the JSONImporter checks if there is a key name 'statements'.
 ;
 ;    void ia(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-Undeclared-ScopArrayInfo.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: JScop file contains access function with undeclared ScopArrayInfo
 ;
 ; Verify that the JSONImporter checks if the access function have a declared ScopArrayInfo.
 ;
 ;    void ia8(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportAccesses/ImportAccesses-Wrong-number-dimensions.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: JScop file changes the number of parameter dimensions.
 ;
 ; Verify that the JSONImporter checks if there is the right parameter dimensions.
 ;
 ;    void ia7(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll

-; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
+  ; RUN: not opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
 ;
 ; CHECK: Array has not a valid type.
 ;
 ; Verify if the JSONImporter checks if the parsed type is valid.
 ;
 ;  for (i = 0; i < _PB_NI; i++)
 ;    for (j = 0; j < _PB_NJ; j++)
 ;      for (k = 0; k < _PB_NK; ++k)

test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll

-; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
+; RUN: not opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
 ;
 ; #define Ni 1056
 ; #define Nj 1056
 ; #define Nk 1024
 ;
 ; void ImportArray_Negative_size(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
 ;   int i,j,k;
 ;

test/JSONExporter/ImportArrays/ImportArrays-No-name.ll

-; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
+; RUN: not opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
 ;
 ; CHECK: Array has no key 'name'.
 ;
 ; Verify if the JSONImporter checks if the arrays have a key name 'name'.
 ;
 ;  for (i = 0; i < _PB_NI; i++)
 ;    for (j = 0; j < _PB_NJ; j++)
 ;      for (k = 0; k < _PB_NK; ++k)

test/JSONExporter/ImportArrays/ImportArrays-No-sizes-key.ll

-; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
+; RUN: not opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
 ;
 ; CHECK: Array has no key 'sizes'.
 ;
 ; Verify if the JSONImporter checks if the arrays have a key name 'sizes'.
 ;
 ;  for (i = 0; i < _PB_NI; i++)
 ;    for (j = 0; j < _PB_NJ; j++)
 ;      for (k = 0; k < _PB_NK; ++k)

test/JSONExporter/ImportArrays/ImportArrays-No-type-key.ll

-; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
+; RUN: not opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
 ;
 ; CHECK: Array has no key 'type'.
 ;
 ; Verify if the JSONImporter checks if the arrays have a key name 'type'.
 ;
 ;  for (i = 0; i < _PB_NI; i++)
 ;    for (j = 0; j < _PB_NJ; j++)
 ;      for (k = 0; k < _PB_NK; ++k)

test/JSONExporter/ImportContext/ImportContext-Context-mispelled.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel  < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: JScop file has no key named 'context'.
 ;
 ; Verify if the JSONImporter check if there is a key name 'context'.
 ;
 ;    void ic(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportContext/ImportContext-Not-parameter-set.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The isl_set is not a parameter set.
 ;
 ; Verify if the JSONImporter check if the imported set is a parameter one.
 ;
 ;    void ic3(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportContext/ImportContext-Unvalid-Context.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The context was not parsed successfully by ISL.
 ;
 ; Verify if the JSONImporter check if the context is parsed successfully.
 ;
 ;    void ic2(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportContext/ImportContext-Wrong-dimension.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: Imported context has the wrong number of parameters : Found 2 Expected 1
 ;
 ; Verify if the JSONImporter check if there is the right number of parameters.
 ;
 ;    void ic4(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportSchedule/ImportSchedule-No-schedule-key.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: Statement 0 has no 'schedule' key.
 ;
 ; Verify if the JSONImporter check if there is a key name 'schedule'.
 ;
 ;    void is3(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportSchedule/ImportSchedule-Schedule-not-valid.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The schedule was not parsed successfully (index = 1).
 ;
 ; Verify if the JSONImporter check if the parsed schedule is valid.
 ;
 ;    void is4(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportSchedule/ImportSchedule-Statements-mispelled.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: JScop file has no key name 'statements'.
 ;
 ; Verify if the JSONImporter check if there is a key name 'statements'.
 ;
 ;    void is(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/JSONExporter/ImportSchedule/ImportSchedule-Wrong-number-statements.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s 
+; RUN: not opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s
 ;
 ; CHECK: The number of indices and the number of statements differ.
 ;
 ; Verify if the JSONImporter check if there is the right number of statements.
 ;
 ;    void is2(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ; S0:    A[0] += i;

test/ScopDetect/base_pointer_load_is_inst_inside_invariant_1___%for.i---%exit.jscop

"arrays" : [
       }
    ],
    "context" : "[n] -> {  : -9223372036854775808 <= n <= 9223372036854775807 }",
    "name" : "%for.i---%exit",
    "statements" : [
       {
          "accesses" : [
             {
-               "kind" : "read",
-               "relation" : "[n] -> { Stmt_S1[i0] -> MemRef_A[0] }"
-            },
-            {
                "kind" : "write",
                "relation" : "[n] -> { Stmt_S1[i0] -> MemRef_ptr[i0+1] }"
             }
          ],
          "domain" : "[n] -> { Stmt_S1[i0] : 0 <= i0 < n }",
          "name" : "Stmt_S1",
          "schedule" : "[n] -> { Stmt_S1[i0] -> [i0] }"
       }
    ]
 }

test/Simplify/notredundant_region_middle.ll

-; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
+; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
 ;
 ; Do not remove redundant stores in the middle of region statements.
 ; The store in region_true could be removed, but in practice we do try to
 ; determine the relative ordering of block in region statements.
 ;
 ; for (int j = 0; j < n; j += 1) {
 ;   double val = A[0];
 ;   if (val == 0.0)