clang-format

Author: vtjnash

llvm/include/llvm/ExecutionEngine/Orc/Core.h

@@ -30,9 +30,9 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ExtensibleRTTI.h"
 
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include <atomic>
 #include <deque>
-#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include <memory>
 #include <vector>
 

llvm/include/llvm/ExecutionEngine/Orc/DylibManager.h

@@ -125,7 +125,6 @@ class UnsupportedExecutorProcessControl : public DylibManager,
   }
 };
 
-
 /// A ExecutorProcessControl implementation targeting the current process.
 class LLVM_ABI SelfExecutorProcessControl : public DylibManager,
                                             private InProcessMemoryAccess {

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

@@ -404,7 +404,7 @@ class LLVM_ABI ExecutorProcessControl {
 class LLVM_ABI InProcessMemoryAccess
     : public ExecutorProcessControl::MemoryAccess {
 public:
-  InProcessMemoryAccess(ExecutorProcessControl &EPC, bool IsArch64Bit) 
+  InProcessMemoryAccess(ExecutorProcessControl &EPC, bool IsArch64Bit)
       : MemoryAccess(EPC), IsArch64Bit(IsArch64Bit) {}
   void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
                         WriteResultFn OnWriteComplete) override;

llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

@@ -133,7 +133,8 @@ template <typename ORCABI> class LocalTrampolinePool : public TrampolinePool {
     return LandingAddressF.get(TrampolinePool->D).getValue();
   }
 
-  LocalTrampolinePool(ResolveLandingFunction ResolveLanding, TaskDispatcher &D, Error &Err)
+  LocalTrampolinePool(ResolveLandingFunction ResolveLanding, TaskDispatcher &D,
+                      Error &Err)
       : ResolveLanding(std::move(ResolveLanding)), D(D) {
 
     ErrorAsOutParameter _(Err);
@@ -269,7 +270,8 @@ class LocalJITCompileCallbackManager : public JITCompileCallbackManager {
         [this](ExecutorAddr TrampolineAddr,
                NotifyLandingResolvedFunction NotifyLandingResolved) {
           NotifyLandingResolved(executeCompileCallback(TrampolineAddr));
-        }, ES.getExecutorProcessControl().getDispatcher());
+        },
+        ES.getExecutorProcessControl().getDispatcher());
 
     if (!TP) {
       Err = TP.takeError();

llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h

@@ -56,7 +56,9 @@ class LazyCallThroughManager {
       ExecutorAddr TrampolineAddr,
       TrampolinePool::NotifyLandingResolvedFunction NotifyLandingResolved);
 
-  TaskDispatcher& getDispatcher() { return ES.getExecutorProcessControl().getDispatcher(); }
+  TaskDispatcher &getDispatcher() {
+    return ES.getExecutorProcessControl().getDispatcher();
+  }
 
   virtual ~LazyCallThroughManager() = default;
 
@@ -104,7 +106,8 @@ class LocalLazyCallThroughManager : public LazyCallThroughManager {
                    NotifyLandingResolved) {
           resolveTrampolineLandingAddress(TrampolineAddr,
                                           std::move(NotifyLandingResolved));
-        }, getDispatcher());
+        },
+        getDispatcher());
 
     if (!TP)
       return TP.takeError();

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/SimpleRemoteEPCServer.h

@@ -21,10 +21,10 @@
 #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/ExecutorBootstrapService.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/SimpleExecutorDylibManager.h"
-#include <future>
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/Error.h"
+#include <future>
 
 #include <condition_variable>
 #include <memory>

llvm/include/llvm/ExecutionEngine/Orc/TaskDispatch.h

@@ -16,8 +16,8 @@
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/ExtensibleRTTI.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ExtensibleRTTI.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <atomic>
@@ -122,23 +122,23 @@ class LLVM_ABI TaskDispatcher {
   virtual void shutdown() = 0;
 
   /// Work on dispatched tasks until the given future is ready.
-  virtual void work_until(future_base& F) = 0;
+  virtual void work_until(future_base &F) = 0;
 };
 
 /// Runs all tasks on the current thread.
 class LLVM_ABI InPlaceTaskDispatcher : public TaskDispatcher {
 public:
   void dispatch(std::unique_ptr<Task> T) override;
   void shutdown() override;
-  void work_until(future_base& F) override;
+  void work_until(future_base &F) override;
 
 private:
   thread_local static SmallVector<std::unique_ptr<Task>> TaskQueue;
-  
+
 #if LLVM_ENABLE_THREADS
   std::mutex DispatchMutex;
   std::condition_variable WorkFinishedCV;
-  SmallVector<future_base*> WaitingFutures;
+  SmallVector<future_base *> WaitingFutures;
 #endif
 };
 
@@ -152,7 +152,8 @@ class LLVM_ABI DynamicThreadPoolTaskDispatcher : public TaskDispatcher {
 
   void dispatch(std::unique_ptr<Task> T) override;
   void shutdown() override;
-  void work_until(future_base& F) override;
+  void work_until(future_base &F) override;
+
 private:
   bool canRunMaterializationTaskNow();
   bool canRunIdleTaskNow();
@@ -171,26 +172,24 @@ class LLVM_ABI DynamicThreadPoolTaskDispatcher : public TaskDispatcher {
 #endif // LLVM_ENABLE_THREADS
 
 /// Status for future/promise state
-enum class FutureStatus : uint8_t {
-  NotReady = 0,
-  Ready = 1,
-  NotValid = 2
-};
+enum class FutureStatus : uint8_t { NotReady = 0, Ready = 1, NotValid = 2 };
 
 /// Type-erased base class for futures
 class future_base {
 public:
   bool is_ready() const {
-    return state_->status_.load(std::memory_order_acquire) != FutureStatus::NotReady;
+    return state_->status_.load(std::memory_order_acquire) !=
+           FutureStatus::NotReady;
   }
 
   /// Check if the future is in a valid state (not moved-from and not consumed)
   bool valid() const {
-    return state_ && state_->status_.load(std::memory_order_acquire) != FutureStatus::NotValid;
+    return state_ && state_->status_.load(std::memory_order_acquire) !=
+                         FutureStatus::NotValid;
   }
 
   /// Wait for the future to be ready, helping with task dispatch
-  void wait(TaskDispatcher& D) {
+  void wait(TaskDispatcher &D) {
     // Keep helping with task dispatch until our future is ready
     if (!is_ready())
       D.work_until(*this);
@@ -202,19 +201,19 @@ class future_base {
     std::atomic<FutureStatus> status_{FutureStatus::NotReady};
   };
 
-  future_base(state_base* state) : state_(state) {}
+  future_base(state_base *state) : state_(state) {}
   future_base() = default;
-  ~future_base() { 
+  ~future_base() {
     if (valid())
       report_fatal_error("get() must be called before future destruction");
-    delete state_; 
+    delete state_;
   }
 
   // Move constructor and assignment
-  future_base(future_base&& other) noexcept : state_(other.state_) {
+  future_base(future_base &&other) noexcept : state_(other.state_) {
     other.state_ = nullptr;
   }
-  future_base& operator=(future_base&& other) noexcept {
+  future_base &operator=(future_base &&other) noexcept {
     if (this != &other) {
       delete state_;
       state_ = other.state_;
@@ -223,87 +222,85 @@ class future_base {
     return *this;
   }
 
-  state_base* state_;
+  state_base *state_;
 };
 
 /// ORC-aware future class that can help with task dispatch while waiting
 
 template <typename T> class future;
 template <typename T> class promise;
-template <typename T>
-class future : public future_base {
+template <typename T> class future : public future_base {
 public:
   struct state : public future_base::state_base {
-    template <typename U>
-    struct value_storage { 
+    template <typename U> struct value_storage {
       U value_;
     };
-    
-    template <>
-    struct value_storage<void> {
+
+    template <> struct value_storage<void> {
       // No value_ member for void
     };
-    
+
     value_storage<T> storage;
   };
 
   future() = delete;
-  future(const future&) = delete;
-  future& operator=(const future&) = delete;
-  future(future&&) = default;
-  future& operator=(future&&) = default;
+  future(const future &) = delete;
+  future &operator=(const future &) = delete;
+  future(future &&) = default;
+  future &operator=(future &&) = default;
 
   /// Get the value, helping with task dispatch while waiting.
   /// This will destroy the underlying value, so this must only be called once.
-  T get(TaskDispatcher& D) {
+  T get(TaskDispatcher &D) {
     if (!valid())
       report_fatal_error("get() must only be called once");
     wait(D);
-    auto old_status = state_->status_.exchange(FutureStatus::NotValid, std::memory_order_release);
+    auto old_status = state_->status_.exchange(FutureStatus::NotValid,
+                                               std::memory_order_release);
     if (old_status != FutureStatus::Ready)
       report_fatal_error("get() must only be called once");
     return take_value();
   }
 
 private:
   friend class promise<T>;
-  
+
   template <typename U = T>
   typename std::enable_if<!std::is_void<U>::value, U>::type take_value() {
-     return std::move(static_cast<typename future<T>::state*>(state_)->storage.value_);
+    return std::move(
+        static_cast<typename future<T>::state *>(state_)->storage.value_);
   }
-  
+
   template <typename U = T>
   typename std::enable_if<std::is_void<U>::value, U>::type take_value() {}
 
-  explicit future(state* state) : future_base(state) {}
+  explicit future(state *state) : future_base(state) {}
 };
 
 /// ORC-aware promise class that works with ORC future
-template <typename T>
-class promise {
+template <typename T> class promise {
   friend class future<T>;
-  
+
 public:
   promise() : state_(new typename future<T>::state()), future_created_(false) {}
-  
+
   ~promise() {
     // Delete state only if get_future() was never called
     if (!future_created_) {
       delete state_;
     }
   }
-  
-  promise(const promise&) = delete;
-  promise& operator=(const promise&) = delete;
-  
-  promise(promise&& other) noexcept 
-    : state_(other.state_), future_created_(other.future_created_) {
+
+  promise(const promise &) = delete;
+  promise &operator=(const promise &) = delete;
+
+  promise(promise &&other) noexcept
+      : state_(other.state_), future_created_(other.future_created_) {
     other.state_ = nullptr;
     other.future_created_ = false;
   }
-  
-  promise& operator=(promise&& other) noexcept {
+
+  promise &operator=(promise &&other) noexcept {
     if (this != &other) {
       if (!future_created_) {
         delete state_;
@@ -329,24 +326,29 @@ class promise {
   // but that if the user calls set_value(v) for any value v that they get a
   // member function error, instead of no member named 'value_'.
   template <typename U = T>
-  void set_value(const typename std::conditional<std::is_void<T>::value, std::nullopt_t, T>::type& value) {
+  void
+  set_value(const typename std::conditional<std::is_void<T>::value,
+                                            std::nullopt_t, T>::type &value) {
     assert(state_ && "Invalid promise state");
     state_->storage.value_ = value;
     state_->status_.store(FutureStatus::Ready, std::memory_order_release);
   }
-  
+
   template <typename U = T>
-  void set_value(typename std::conditional<std::is_void<T>::value, std::nullopt_t, T>::type&& value) {
+  void set_value(typename std::conditional<std::is_void<T>::value,
+                                           std::nullopt_t, T>::type &&value) {
     assert(state_ && "Invalid promise state");
     state_->storage.value_ = std::move(value);
     state_->status_.store(FutureStatus::Ready, std::memory_order_release);
   }
 
   template <typename U = T>
-  typename std::enable_if<std::is_void<U>::value, void>::type set_value(const std::nullopt_t& value) = delete;
+  typename std::enable_if<std::is_void<U>::value, void>::type
+  set_value(const std::nullopt_t &value) = delete;
 
   template <typename U = T>
-  typename std::enable_if<std::is_void<U>::value, void>::type set_value(std::nullopt_t&& value) = delete;
+  typename std::enable_if<std::is_void<U>::value, void>::type
+  set_value(std::nullopt_t &&value) = delete;
 
   template <typename U = T>
   typename std::enable_if<std::is_void<U>::value, void>::type set_value() {
@@ -355,14 +357,14 @@ class promise {
   }
 
   /// Swap with another promise
-  void swap(promise& other) noexcept {
+  void swap(promise &other) noexcept {
     using std::swap;
     swap(state_, other.state_);
     swap(future_created_, other.future_created_);
   }
 
 private:
-  typename future<T>::state* state_;
+  typename future<T>::state *state_;
   bool future_created_;
 };
 
@@ -371,7 +373,7 @@ class promise {
 
 namespace std {
 template <typename T>
-void swap(llvm::orc::promise<T>& lhs, llvm::orc::promise<T>& rhs) noexcept {
+void swap(llvm::orc::promise<T> &lhs, llvm::orc::promise<T> &rhs) noexcept {
   lhs.swap(rhs);
 }
 } // End namespace std

llvm/lib/ExecutionEngine/Orc/Core.cpp

@@ -16,8 +16,8 @@
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 #include "llvm/Support/raw_ostream.h"
 
-#include <condition_variable>
 #include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
+#include <condition_variable>
 #include <optional>
 
 #define DEBUG_TYPE "orc"
@@ -1863,7 +1863,8 @@ ExecutionSession::lookup(const JITDylibSearchOrder &SearchOrder,
          std::move(NotifyComplete), RegisterDependencies);
 
 #if LLVM_ENABLE_THREADS
-  return PromisedResult.get_future().get(getExecutorProcessControl().getDispatcher());
+  return PromisedResult.get_future().get(
+      getExecutorProcessControl().getDispatcher());
 #else
   if (ResolutionError)
     return std::move(ResolutionError);