Fix clang format

Author: cjappl

clang/lib/CodeGen/BackendUtil.cpp

@@ -993,9 +993,9 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
 
     if (LangOpts.Sanitize.has(SanitizerKind::Realtime)) {
       PB.registerLoopOptimizerEndEPCallback(
-        [](LoopPassManager &LPM, OptimizationLevel Level) {
-          LPM.addPass(RealtimeSanitizerLoopPass());
-        });
+          [](LoopPassManager &LPM, OptimizationLevel Level) {
+            LPM.addPass(RealtimeSanitizerLoopPass());
+          });
       PB.registerScalarOptimizerLateEPCallback(
           [](FunctionPassManager &FPM, OptimizationLevel Level) {
             RealtimeSanitizerOptions Opts;

compiler-rt/test/rtsan/bound_loop.cpp

@@ -17,23 +17,24 @@
 
 #include <assert.h>
 
-
-void FillBufferInterleaved(int* buffer, int sample_count, int channel_count) [[clang::nonblocking]] {
+void FillBufferInterleaved(int *buffer, int sample_count, int channel_count)
+    [[clang::nonblocking]] {
   for (int sample = 0; sample < sample_count; sample++)
     for (int channel = 0; channel < channel_count; channel++)
       buffer[sample * channel_count + channel] = sample;
 }
 
-void Deinterleave(int* buffer, int sample_count, int channel_count, int* scratch_buffer) [[clang::nonblocking]] {
+void Deinterleave(int *buffer, int sample_count, int channel_count,
+                  int *scratch_buffer) [[clang::nonblocking]] {
   for (int channel = 0; channel < channel_count; channel++)
     for (int sample = 0; sample < sample_count; sample++) {
-          int interleaved_index = sample * channel_count + channel;
-          int deinterleaved_index = channel * sample_count + sample;
-          scratch_buffer[deinterleaved_index] = buffer[interleaved_index];
-      }
+      int interleaved_index = sample * channel_count + channel;
+      int deinterleaved_index = channel * sample_count + sample;
+      scratch_buffer[deinterleaved_index] = buffer[interleaved_index];
+    }
 
   for (int i = 0; i < sample_count * channel_count; i++)
-      buffer[i] = scratch_buffer[i];
+    buffer[i] = scratch_buffer[i];
 }
 
 int main() {

compiler-rt/test/rtsan/infinite_loop.cpp

@@ -8,7 +8,8 @@
 #include <stdlib.h>
 
 void infinity() [[clang::nonblocking]] {
-  while(true);
+  while (true)
+    ;
 }
 
 int main() {

compiler-rt/test/rtsan/spinlock.cpp

@@ -10,53 +10,46 @@
 
 class SpinLockTestAndSet {
 public:
-    void lock() {
-        while (lock_flag.test_and_set(std::memory_order_acquire)) {
-            // Busy-wait (spin) until the lock is acquired
-        }
+  void lock() {
+    while (lock_flag.test_and_set(std::memory_order_acquire)) {
+      // Busy-wait (spin) until the lock is acquired
     }
+  }
 
-    void unlock() {
-        lock_flag.clear(std::memory_order_release);
-    }
+  void unlock() { lock_flag.clear(std::memory_order_release); }
 
 private:
-    std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
+  std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
 };
 
 class SpinLockCompareExchange {
 public:
-    void lock() {
-        bool expected = false;
-        while (!lock_flag.compare_exchange_weak(expected, true, std::memory_order_acquire, std::memory_order_relaxed)) {
-        }
+  void lock() {
+    bool expected = false;
+    while (!lock_flag.compare_exchange_weak(
+        expected, true, std::memory_order_acquire, std::memory_order_relaxed)) {
     }
+  }
 
-    void unlock() {
-        lock_flag.store(false, std::memory_order_release);
-    }
+  void unlock() { lock_flag.store(false, std::memory_order_release); }
 
 private:
-    std::atomic<bool> lock_flag{false};
+  std::atomic<bool> lock_flag{false};
 };
 
-int lock_violation() [[clang::nonblocking]]
-{
+int lock_violation() [[clang::nonblocking]] {
 #if defined(TEST_AND_SET_SPINLOCK)
-    SpinLockTestAndSet lock;
+  SpinLockTestAndSet lock;
 #elif defined(CAS_SPINLOCK)
-    SpinLockCompareExchange lock;
+  SpinLockCompareExchange lock;
 #else
-#error "No spinlock defined"
+#  error "No spinlock defined"
 #endif
-    lock.lock();
-    return 0;
+  lock.lock();
+  return 0;
 }
 
-int main() [[clang::nonblocking]]
-{
-  lock_violation();
-}
+int main() [[clang::nonblocking]] { lock_violation(); }
 
 // CHECK-ALL: {{.*Real-time violation.*}}
 // CHECK-CAS: {{.*SpinLockCompareExchange::lock.*}}

compiler-rt/test/rtsan/unbound_loop.cpp

@@ -17,8 +17,8 @@
 
 #include <assert.h>
 
-
-void BadScalarEvolution(int* buffer, int sample_count, int channel_count) [[clang::nonblocking]] {
+void BadScalarEvolution(int *buffer, int sample_count, int channel_count)
+    [[clang::nonblocking]] {
 
   int sample = 0;
   while (sample < sample_count) {

llvm/lib/Transforms/Instrumentation/RealtimeSanitizer.cpp

@@ -75,17 +75,20 @@ PreservedAnalyses RealtimeSanitizerPass::run(Function &F,
   return PreservedAnalyses::all();
 }
 
-PreservedAnalyses RealtimeSanitizerLoopPass::run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U) {
+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");
 
-  Function* F = Context->getParent();
+  Function *F = Context->getParent();
   assert(F && "Loop has no parent function");
 
   const bool HasNoExits = L.hasNoExitBlocks();
-  const bool CannotPredictLoopCount = isa<SCEVCouldNotCompute>(AR.SE.getConstantMaxBackedgeTakenCount(&L)) ||
-        isa<SCEVCouldNotCompute>(AR.SE.getBackedgeTakenCount(&L));
+  const bool CannotPredictLoopCount =
+      isa<SCEVCouldNotCompute>(AR.SE.getConstantMaxBackedgeTakenCount(&L)) ||
+      isa<SCEVCouldNotCompute>(AR.SE.getBackedgeTakenCount(&L));
   const bool LoopIsPotentiallyUnbound = HasNoExits || CannotPredictLoopCount;
 
   if (LoopIsPotentiallyUnbound) {
@@ -107,8 +110,7 @@ PreservedAnalyses RealtimeSanitizerLoopPass::run(Loop &L, LoopAnalysisManager &A
 
     // TODO: What is preserved here??
     return PreservedAnalyses::none();
-    }
+  }
 
   return PreservedAnalyses::all();
 }
-