WIP: Loop pass

Author: cjappl

clang/lib/CodeGen/BackendUtil.cpp

@@ -991,12 +991,18 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
             FPM.addPass(BoundsCheckingPass());
           });
 
-    if (LangOpts.Sanitize.has(SanitizerKind::Realtime))
+    if (LangOpts.Sanitize.has(SanitizerKind::Realtime)) {
+      fprintf(stderr, "Adding RealtimeSanitizerPass\n");
+      PB.registerLoopOptimizerEndEPCallback(
+        [](LoopPassManager &LPM, OptimizationLevel Level) {
+          LPM.addPass(RealtimeSanitizerLoopPass());
+        });
       PB.registerScalarOptimizerLateEPCallback(
           [](FunctionPassManager &FPM, OptimizationLevel Level) {
             RealtimeSanitizerOptions Opts;
             FPM.addPass(RealtimeSanitizerPass(Opts));
           });
+    }
 
     // Don't add sanitizers if we are here from ThinLTO PostLink. That already
     // done on PreLink stage.

llvm/include/llvm/Transforms/Instrumentation/RealtimeSanitizer.h

@@ -20,6 +20,8 @@
 #define LLVM_TRANSFORMS_INSTRUMENTATION_REALTIMESANITIZER_H
 
 #include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
 
 namespace llvm {
 
@@ -33,6 +35,13 @@ class RealtimeSanitizerPass : public PassInfoMixin<RealtimeSanitizerPass> {
   static bool isRequired() { return true; }
 };
 
+struct RealtimeSanitizerLoopPass : PassInfoMixin<RealtimeSanitizerLoopPass> {
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static bool isRequired() { return true; }
+};
+
+
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_REALTIMESANITIZER_H

llvm/lib/Passes/PassRegistry.def

@@ -659,6 +659,7 @@ LOOP_PASS("print<ddg>", DDGAnalysisPrinterPass(dbgs()))
 LOOP_PASS("print<iv-users>", IVUsersPrinterPass(dbgs()))
 LOOP_PASS("print<loop-cache-cost>", LoopCachePrinterPass(dbgs()))
 LOOP_PASS("print<loopnest>", LoopNestPrinterPass(dbgs()))
+LOOP_PASS("sanitize-unbound-loops", RealtimeSanitizerLoopPass())
 #undef LOOP_PASS
 
 #ifndef LOOP_PASS_WITH_PARAMS

llvm/lib/Transforms/Instrumentation/RealtimeSanitizer.cpp

@@ -71,43 +71,43 @@ PreservedAnalyses RealtimeSanitizerPass::run(Function &F,
     PA.preserveSet<CFGAnalyses>();
   }
 
-  const LoopInfo &LI = AM.getResult<LoopAnalysis>(F);
-  ScalarEvolution &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
-  for (Loop *L : LI) {
+  return PA;
+}
 
-    const bool HasNoExits = L->hasNoExitBlocks();
-    const bool CannotPredictLoopCount =
-        isa<SCEVCouldNotCompute>(SE.getConstantMaxBackedgeTakenCount(L)) &&
-        isa<SCEVCouldNotCompute>(SE.getBackedgeTakenCount(L));
-    const bool LoopIsPotentiallyUnbound = HasNoExits || CannotPredictLoopCount;
+PreservedAnalyses RealtimeSanitizerLoopPass::run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U) {
+  BasicBlock *Context =
+      L.getLoopPreheader() ? L.getLoopPreheader() : L.getHeader();
+  assert(Context && "Loop has no preheader or header block");
 
-    if (LoopIsPotentiallyUnbound) {
-      BasicBlock *Context =
-          L->getLoopPreheader() ? L->getLoopPreheader() : L->getHeader();
-      assert(Context && "Loop has no preheader or header block");
+  Function* F = Context->getParent();
+  assert(F && "Loop has no parent function");
 
-      IRBuilder<> Builder{&Context->back()};
+  const bool HasNoExits = L.hasNoExitBlocks();
+  const bool CannotPredictLoopCount = isa<SCEVCouldNotCompute>(AR.SE.getConstantMaxBackedgeTakenCount(&L)) &&
+        isa<SCEVCouldNotCompute>(AR.SE.getBackedgeTakenCount(&L));
+  const bool LoopIsPotentiallyUnbound = HasNoExits || CannotPredictLoopCount;
 
-      std::string ReasonStr =
-          demangle(F.getName().str()) + " contains a possibly unbounded loop ";
+  if (LoopIsPotentiallyUnbound) {
+    IRBuilder<> Builder{&Context->back()};
 
-      if (HasNoExits)
-        ReasonStr += "(reason: no exit blocks).";
-      else if (CannotPredictLoopCount)
-        ReasonStr += "(reason: backedge taken count cannot be computed).";
-      else
-        assert(false);
+    std::string ReasonStr =
+        demangle(F->getName().str()) + " contains a possibly unbounded loop ";
 
-      Value *Reason = Builder.CreateGlobalStringPtr(ReasonStr);
-      insertCallBeforeInstruction(F, Builder, "__rtsan_expect_not_realtime",
-                                  {Reason});
+    if (HasNoExits)
+      ReasonStr += "(reason: no exit blocks).";
+    else if (CannotPredictLoopCount)
+      ReasonStr += "(reason: backedge taken count cannot be computed).";
+    else
+      assert(false);
 
-      // TODO: What is preserved here??
-      PA = PreservedAnalyses::none();
+    Value *Reason = Builder.CreateGlobalStringPtr(ReasonStr);
+    insertCallBeforeInstruction(*F, Builder, "__rtsan_expect_not_realtime",
+                                {Reason});
 
-      // TODO: Tons of test cases
+    // TODO: What is preserved here??
+    return PreservedAnalyses::none();
     }
-  }
 
-  return PA;
+  return PreservedAnalyses::all();
 }
+

llvm/test/Instrumentation/RealtimeSanitizer/rtsan_bound_loop.ll

@@ -1,4 +1,4 @@
-; RUN: opt < %s -passes='rtsan' -S | FileCheck %s
+; RUN: opt < %s -passes='sroa,sanitize-unbound-loops' -S | FileCheck %s
 
 
 define void @procces(ptr noundef %buffer, i32 noundef %size) #0 {
@@ -40,9 +40,4 @@ for.end:                                          ; preds = %for.cond
 attributes #0 = { sanitize_realtime }
 
 ; In this simple loop, we should not insert rtsan_expect_not_realtime
-; CHECK: call{{.*}}@__rtsan_realtime_enter
-
-; TODO: This test fails when it shouldn't!!
-; XXXXX--CHECK-NOT: call{{.*}}@__rtsan_expect_not_realtime
-
-; CHECK: call{{.*}}@__rtsan_realtime_exit
+; CHECK-NOT: call{{.*}}@__rtsan_expect_not_realtime

llvm/test/Instrumentation/RealtimeSanitizer/rtsan_cas_spinlock.ll

@@ -1,4 +1,4 @@
-; RUN: opt < %s -passes=rtsan -S | FileCheck %s
+; RUN: opt < %s -passes='sanitize-unbound-loops' -S | FileCheck %s
 
 %class.SpinLockTestAndSet = type { %"struct.std::__1::atomic_flag" }
 %"struct.std::__1::atomic_flag" = type { %"struct.std::__1::__cxx_atomic_impl" }
@@ -25,6 +25,4 @@ SpinlockTestAndSet.exit:              ; preds = %while.cond.i
 
 attributes #0 = { sanitize_realtime }
 
-; CHECK: call{{.*}}@__rtsan_realtime_enter
 ; CHECK: call{{.*}}@__rtsan_expect_not_realtime
-; CHECK: call{{.*}}@__rtsan_realtime_exit

llvm/test/Instrumentation/RealtimeSanitizer/rtsan_infinite_loop.ll

@@ -1,4 +1,4 @@
-; RUN: opt < %s -passes=rtsan -S | FileCheck %s
+; RUN: opt < %s -passes='sanitize-unbound-loops' -S | FileCheck %s
 
 define void @process() #0 {
 entry:
@@ -10,6 +10,5 @@ while.body:                                       ; preds = %entry, %while.body
 
 attributes #0 = { sanitize_realtime }
 
-; CHECK: call{{.*}}@__rtsan_realtime_enter
 ; CHECK: call{{.*}}@__rtsan_expect_not_realtime
 ; CHECK-NEXT: br label %while.body