[ORC] clang-format code that was touched in r267457. NFC.

Commit r267457 made a lot of type-substitutions threw off code formatting and
alignment. This patch should tidy those changes up.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@267475 91177308-0d34-0410-b5e6-96231b3b80d8

11 files changed, 322 insertions, 402 deletions

diff --git a/include/llvm-c/OrcBindings.h b/include/llvm-c/OrcBindings.h
index 4a2fa26abd4..de2969ab1c9 100644
--- a/include/llvm-c/OrcBindings.h
+++ b/include/llvm-c/OrcBindings.h
@@ -32,15 +32,11 @@ extern "C" {
 typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
 typedef uint32_t LLVMOrcModuleHandle;
 typedef uint64_t LLVMOrcTargetAddress;
-typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name,
-                                            void *LookupCtx);
+typedef uint64_t (*LLVMOrcSymbolResolverFn)(const char *Name, void *LookupCtx);
 typedef uint64_t (*LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack,
                                                  void *CallbackCtx);
 
-typedef enum {
-  LLVMOrcErrSuccess = 0,
-  LLVMOrcErrGeneric
-} LLVMOrcErrorCode;
+typedef enum { LLVMOrcErrSuccess = 0, LLVMOrcErrGeneric } LLVMOrcErrorCode;
 
 /**
  * Create an ORC JIT stack.
@@ -114,10 +110,10 @@ LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack, LLVMModuleRef Mod,
 /**
  * Add an object file.
  */
-LLVMOrcModuleHandle
-LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack, LLVMObjectFileRef Obj,
-                     LLVMOrcSymbolResolverFn SymbolResolver,
-                     void *SymbolResolverCtx);
+LLVMOrcModuleHandle LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
+                                         LLVMObjectFileRef Obj,
+                                         LLVMOrcSymbolResolverFn SymbolResolver,
+                                         void *SymbolResolverCtx);
 
 /**
  * Remove a module set from the JIT.
diff --git a/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h b/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
index 615d6369a64..03306985a3e 100644
--- a/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
+++ b/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
@@ -29,7 +29,6 @@ namespace orc {
 /// @brief Target-independent base class for compile callback management.
 class JITCompileCallbackManager {
 public:
-
   typedef std::function<TargetAddress()> CompileFtor;
 
   /// @brief Handle to a newly created compile callback. Can be used to get an
@@ -38,12 +37,13 @@ public:
   class CompileCallbackInfo {
   public:
     CompileCallbackInfo(TargetAddress Addr, CompileFtor &Compile)
-      : Addr(Addr), Compile(Compile) {}
+        : Addr(Addr), Compile(Compile) {}
 
     TargetAddress getAddress() const { return Addr; }
     void setCompileAction(CompileFtor Compile) {
       this->Compile = std::move(Compile);
     }
+
   private:
     TargetAddress Addr;
     CompileFtor &Compile;
@@ -53,7 +53,7 @@ public:
   /// @param ErrorHandlerAddress The address of an error handler in the target
   ///                            process to be used if a compile callback fails.
   JITCompileCallbackManager(TargetAddress ErrorHandlerAddress)
-    : ErrorHandlerAddress(ErrorHandlerAddress) {}
+      : ErrorHandlerAddress(ErrorHandlerAddress) {}
 
   virtual ~JITCompileCallbackManager() {}
 
@@ -69,8 +69,10 @@ public:
     // Found a callback handler. Yank this trampoline out of the active list and
     // put it back in the available trampolines list, then try to run the
     // handler's compile and update actions.
-    // Moving the trampoline ID back to the available list first means there's at
-    // least one available trampoline if the compile action triggers a request for
+    // Moving the trampoline ID back to the available list first means there's
+    // at
+    // least one available trampoline if the compile action triggers a request
+    // for
     // a new one.
     auto Compile = std::move(I->second);
     ActiveTrampolines.erase(I);
@@ -116,7 +118,6 @@ protected:
   std::vector<TargetAddress> AvailableTrampolines;
 
 private:
-
   TargetAddress getAvailableTrampolineAddr() {
     if (this->AvailableTrampolines.empty())
       grow();
@@ -137,20 +138,17 @@ private:
 template <typename TargetT>
 class LocalJITCompileCallbackManager : public JITCompileCallbackManager {
 public:
-
   /// @brief Construct a InProcessJITCompileCallbackManager.
   /// @param ErrorHandlerAddress The address of an error handler in the target
   ///                            process to be used if a compile callback fails.
   LocalJITCompileCallbackManager(TargetAddress ErrorHandlerAddress)
-    : JITCompileCallbackManager(ErrorHandlerAddress) {
+      : JITCompileCallbackManager(ErrorHandlerAddress) {
 
     /// Set up the resolver block.
     std::error_code EC;
-    ResolverBlock =
-      sys::OwningMemoryBlock(
-        sys::Memory::allocateMappedMemory(TargetT::ResolverCodeSize, nullptr,
-                                          sys::Memory::MF_READ |
-                                          sys::Memory::MF_WRITE, EC));
+    ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+        TargetT::ResolverCodeSize, nullptr,
+        sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     assert(!EC && "Failed to allocate resolver block");
 
     TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
@@ -163,13 +161,11 @@ public:
   }
 
 private:
-
   static TargetAddress reenter(void *CCMgr, void *TrampolineId) {
     JITCompileCallbackManager *Mgr =
-      static_cast<JITCompileCallbackManager*>(CCMgr);
+        static_cast<JITCompileCallbackManager *>(CCMgr);
     return Mgr->executeCompileCallback(
-             static_cast<TargetAddress>(
-               reinterpret_cast<uintptr_t>(TrampolineId)));
+        static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(TrampolineId)));
   }
 
   void grow() override {
@@ -177,18 +173,16 @@ private:
 
     std::error_code EC;
     auto TrampolineBlock =
-      sys::OwningMemoryBlock(
-        sys::Memory::allocateMappedMemory(sys::Process::getPageSize(), nullptr,
-                                          sys::Memory::MF_READ |
-                                          sys::Memory::MF_WRITE, EC));
+        sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+            sys::Process::getPageSize(), nullptr,
+            sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     assert(!EC && "Failed to allocate trampoline block");
 
-
     unsigned NumTrampolines =
-      (sys::Process::getPageSize() - TargetT::PointerSize) /
+        (sys::Process::getPageSize() - TargetT::PointerSize) /
         TargetT::TrampolineSize;
 
-    uint8_t *TrampolineMem = static_cast<uint8_t*>(TrampolineBlock.base());
+    uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
     TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
                               NumTrampolines);
 
@@ -212,7 +206,6 @@ private:
 /// @brief Base class for managing collections of named indirect stubs.
 class IndirectStubsManager {
 public:
-
   /// @brief Map type for initializing the manager. See init.
   typedef StringMap<std::pair<TargetAddress, JITSymbolFlags>> StubInitsMap;
 
@@ -236,6 +229,7 @@ public:
 
   /// @brief Change the value of the implementation pointer for the stub.
   virtual Error updatePointer(StringRef Name, TargetAddress NewAddr) = 0;
+
 private:
   virtual void anchor();
 };
@@ -245,9 +239,8 @@ private:
 template <typename TargetT>
 class LocalIndirectStubsManager : public IndirectStubsManager {
 public:
-
   Error createStub(StringRef StubName, TargetAddress StubAddr,
-                             JITSymbolFlags StubFlags) override {
+                   JITSymbolFlags StubFlags) override {
     if (auto Err = reserveStubs(1))
       return Err;
 
@@ -275,7 +268,7 @@ public:
     void *StubAddr = IndirectStubsInfos[Key.first].getStub(Key.second);
     assert(StubAddr && "Missing stub address");
     auto StubTargetAddr =
-      static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
+        static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
     auto StubSymbol = JITSymbol(StubTargetAddr, I->second.second);
     if (ExportedStubsOnly && !StubSymbol.isExported())
       return nullptr;
@@ -290,7 +283,7 @@ public:
     void *PtrAddr = IndirectStubsInfos[Key.first].getPtr(Key.second);
     assert(PtrAddr && "Missing pointer address");
     auto PtrTargetAddr =
-      static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
+        static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
     return JITSymbol(PtrTargetAddr, I->second.second);
   }
 
@@ -299,12 +292,11 @@ public:
     assert(I != StubIndexes.end() && "No stub pointer for symbol");
     auto Key = I->second.first;
     *IndirectStubsInfos[Key.first].getPtr(Key.second) =
-      reinterpret_cast<void*>(static_cast<uintptr_t>(NewAddr));
+        reinterpret_cast<void *>(static_cast<uintptr_t>(NewAddr));
     return Error::success();
   }
 
 private:
-
   Error reserveStubs(unsigned NumStubs) {
     if (NumStubs <= FreeStubs.size())
       return Error::success();
@@ -312,8 +304,8 @@ private:
     unsigned NewStubsRequired = NumStubs - FreeStubs.size();
     unsigned NewBlockId = IndirectStubsInfos.size();
     typename TargetT::IndirectStubsInfo ISI;
-    if (auto Err = TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired,
-                                                  nullptr))
+    if (auto Err =
+            TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired, nullptr))
       return Err;
     for (unsigned I = 0; I < ISI.getNumStubs(); ++I)
       FreeStubs.push_back(std::make_pair(NewBlockId, I));
@@ -326,7 +318,7 @@ private:
     auto Key = FreeStubs.back();
     FreeStubs.pop_back();
     *IndirectStubsInfos[Key.first].getPtr(Key.second) =
-      reinterpret_cast<void*>(static_cast<uintptr_t>(InitAddr));
+        reinterpret_cast<void *>(static_cast<uintptr_t>(InitAddr));
     StubIndexes[StubName] = std::make_pair(Key, StubFlags);
   }
 
@@ -341,12 +333,12 @@ private:
 ///
 ///   Usage example: Turn a trampoline address into a function pointer constant
 /// for use in a stub.
-Constant* createIRTypedAddress(FunctionType &FT, TargetAddress Addr);
+Constant *createIRTypedAddress(FunctionType &FT, TargetAddress Addr);
 
 /// @brief Create a function pointer with the given type, name, and initializer
 ///        in the given Module.
-GlobalVariable* createImplPointer(PointerType &PT, Module &M,
-                                  const Twine &Name, Constant *Initializer);
+GlobalVariable *createImplPointer(PointerType &PT, Module &M, const Twine &Name,
+                                  Constant *Initializer);
 
 /// @brief Turn a function declaration into a stub function that makes an
 ///        indirect call using the given function pointer.
@@ -371,7 +363,7 @@ void makeAllSymbolsExternallyAccessible(Module &M);
 /// modules with these utilities, all decls should be cloned (and added to a
 /// single VMap) before any bodies are moved. This will ensure that references
 /// between functions all refer to the versions in the new module.
-Function* cloneFunctionDecl(Module &Dst, const Function &F,
+Function *cloneFunctionDecl(Module &Dst, const Function &F,
                             ValueToValueMapTy *VMap = nullptr);
 
 /// @brief Move the body of function 'F' to a cloned function declaration in a
@@ -387,7 +379,7 @@ void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap,
                       Function *NewF = nullptr);
 
 /// @brief Clone a global variable declaration into a new module.
-GlobalVariable* cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
+GlobalVariable *cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
                                         ValueToValueMapTy *VMap = nullptr);
 
 /// @brief Move global variable GV from its parent module to cloned global
@@ -404,7 +396,7 @@ void moveGlobalVariableInitializer(GlobalVariable &OrigGV,
                                    GlobalVariable *NewGV = nullptr);
 
 /// @brief Clone
-GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
+GlobalAlias *cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
                                   ValueToValueMapTy &VMap);
 
 } // End namespace orc.
diff --git a/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h b/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
index df0b5fe1cf4..74d851522f7 100644
--- a/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
+++ b/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
@@ -28,19 +28,19 @@ class DirectBufferWriter {
 public:
   DirectBufferWriter() = default;
   DirectBufferWriter(const char *Src, TargetAddress Dst, uint64_t Size)
-    : Src(Src), Dst(Dst), Size(Size) {}
+      : Src(Src), Dst(Dst), Size(Size) {}
 
   const char *getSrc() const { return Src; }
   TargetAddress getDst() const { return Dst; }
   uint64_t getSize() const { return Size; }
+
 private:
   const char *Src;
   TargetAddress Dst;
   uint64_t Size;
 };
 
-inline Error serialize(RPCChannel &C,
-                       const DirectBufferWriter &DBW) {
+inline Error serialize(RPCChannel &C, const DirectBufferWriter &DBW) {
   if (auto EC = serialize(C, DBW.getDst()))
     return EC;
   if (auto EC = serialize(C, DBW.getSize()))
@@ -48,15 +48,14 @@ inline Error serialize(RPCChannel &C,
   return C.appendBytes(DBW.getSrc(), DBW.getSize());
 }
 
-inline Error deserialize(RPCChannel &C,
-                         DirectBufferWriter &DBW) {
+inline Error deserialize(RPCChannel &C, DirectBufferWriter &DBW) {
   TargetAddress Dst;
   if (auto EC = deserialize(C, Dst))
     return EC;
   uint64_t Size;
   if (auto EC = deserialize(C, Size))
     return EC;
-  char *Addr = reinterpret_cast<char*>(static_cast<uintptr_t>(Dst));
+  char *Addr = reinterpret_cast<char *>(static_cast<uintptr_t>(Dst));
 
   DBW = DirectBufferWriter(0, Dst, Size);
 
@@ -65,7 +64,6 @@ inline Error deserialize(RPCChannel &C,
 
 class OrcRemoteTargetRPCAPI : public RPC<RPCChannel> {
 protected:
-
   class ResourceIdMgr {
   public:
     typedef uint64_t ResourceId;
@@ -87,16 +85,13 @@ protected:
   };
 
 public:
-
   // FIXME: Remove constructors once MSVC supports synthesizing move-ops.
   OrcRemoteTargetRPCAPI() = default;
-  OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI&) = delete;
-  OrcRemoteTargetRPCAPI& operator=(const OrcRemoteTargetRPCAPI&) = delete;
+  OrcRemoteTargetRPCAPI(const OrcRemoteTargetRPCAPI &) = delete;
+  OrcRemoteTargetRPCAPI &operator=(const OrcRemoteTargetRPCAPI &) = delete;
 
-  OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI&&) {}
-  OrcRemoteTargetRPCAPI& operator=(OrcRemoteTargetRPCAPI&&) {
-    return *this;
-  }
+  OrcRemoteTargetRPCAPI(OrcRemoteTargetRPCAPI &&) {}
+  OrcRemoteTargetRPCAPI &operator=(OrcRemoteTargetRPCAPI &&) { return *this; }
 
   enum JITFuncId : uint32_t {
     InvalidId = RPCFunctionIdTraits<JITFuncId>::InvalidId,
@@ -127,80 +122,78 @@ public:
 
   typedef Function<CallIntVoidId, int32_t(TargetAddress Addr)> CallIntVoid;
 
-  typedef Function<CallMainId, int32_t(TargetAddress Addr,
-				       std::vector<std::string> Args)>
+  typedef Function<CallMainId,
+                   int32_t(TargetAddress Addr, std::vector<std::string> Args)>
       CallMain;
 
   typedef Function<CallVoidVoidId, void(TargetAddress FnAddr)> CallVoidVoid;
 
   typedef Function<CreateRemoteAllocatorId,
-		   void(ResourceIdMgr::ResourceId AllocatorID)>
+                   void(ResourceIdMgr::ResourceId AllocatorID)>
       CreateRemoteAllocator;
 
   typedef Function<CreateIndirectStubsOwnerId,
-		   void(ResourceIdMgr::ResourceId StubOwnerID)>
-    CreateIndirectStubsOwner;
+                   void(ResourceIdMgr::ResourceId StubOwnerID)>
+      CreateIndirectStubsOwner;
 
   typedef Function<DeregisterEHFramesId,
-		   void(TargetAddress Addr, uint32_t Size)>
+                   void(TargetAddress Addr, uint32_t Size)>
       DeregisterEHFrames;
 
   typedef Function<DestroyRemoteAllocatorId,
-		   void(ResourceIdMgr::ResourceId AllocatorID)>
+                   void(ResourceIdMgr::ResourceId AllocatorID)>
       DestroyRemoteAllocator;
 
   typedef Function<DestroyIndirectStubsOwnerId,
-		   void(ResourceIdMgr::ResourceId StubsOwnerID)>
+                   void(ResourceIdMgr::ResourceId StubsOwnerID)>
       DestroyIndirectStubsOwner;
 
   /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
   typedef Function<EmitIndirectStubsId,
-		   std::tuple<TargetAddress, TargetAddress, uint32_t>(
-                        ResourceIdMgr::ResourceId StubsOwnerID,
-			uint32_t NumStubsRequired)>
+                   std::tuple<TargetAddress, TargetAddress, uint32_t>(
+                       ResourceIdMgr::ResourceId StubsOwnerID,
+                       uint32_t NumStubsRequired)>
       EmitIndirectStubs;
 
   typedef Function<EmitResolverBlockId, void()> EmitResolverBlock;
 
   /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
-  typedef Function<EmitTrampolineBlockId,
-		   std::tuple<TargetAddress, uint32_t>()> EmitTrampolineBlock;
+  typedef Function<EmitTrampolineBlockId, std::tuple<TargetAddress, uint32_t>()>
+      EmitTrampolineBlock;
 
   typedef Function<GetSymbolAddressId, TargetAddress(std::string SymbolName)>
       GetSymbolAddress;
 
   /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
   ///                          IndirectStubsSize).
-  typedef Function<GetRemoteInfoId,
-		   std::tuple<std::string, uint32_t, uint32_t, uint32_t,
-			      uint32_t>()> GetRemoteInfo;
+  typedef Function<GetRemoteInfoId, std::tuple<std::string, uint32_t, uint32_t,
+                                               uint32_t, uint32_t>()>
+      GetRemoteInfo;
 
   typedef Function<ReadMemId,
-		   std::vector<char>(TargetAddress Src, uint64_t Size)>
+                   std::vector<char>(TargetAddress Src, uint64_t Size)>
       ReadMem;
 
-  typedef Function<RegisterEHFramesId,
-		   void(TargetAddress Addr, uint32_t Size)>
+  typedef Function<RegisterEHFramesId, void(TargetAddress Addr, uint32_t Size)>
       RegisterEHFrames;
 
   typedef Function<ReserveMemId,
-		   TargetAddress(ResourceIdMgr::ResourceId AllocID,
-				 uint64_t Size, uint32_t Align)>
+                   TargetAddress(ResourceIdMgr::ResourceId AllocID,
+                                 uint64_t Size, uint32_t Align)>
       ReserveMem;
 
   typedef Function<RequestCompileId,
-		   TargetAddress(TargetAddress TrampolineAddr)>
+                   TargetAddress(TargetAddress TrampolineAddr)>
       RequestCompile;
 
   typedef Function<SetProtectionsId,
-		   void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
-			uint32_t ProtFlags)>
+                   void(ResourceIdMgr::ResourceId AllocID, TargetAddress Dst,
+                        uint32_t ProtFlags)>
       SetProtections;
 
   typedef Function<TerminateSessionId, void()> TerminateSession;
 
-  typedef Function<WriteMemId, void(DirectBufferWriter DB)>
-      WriteMem;
+  typedef Function<WriteMemId, void(DirectBufferWriter DB)> WriteMem;
 
   typedef Function<WritePtrId, void(TargetAddress Dst, TargetAddress Val)>
       WritePtr;
diff --git a/include/llvm/ExecutionEngine/Orc/RPCUtils.h b/include/llvm/ExecutionEngine/Orc/RPCUtils.h
index ee5ccf98c04..966a4968434 100644
--- a/include/llvm/ExecutionEngine/Orc/RPCUtils.h
+++ b/include/llvm/ExecutionEngine/Orc/RPCUtils.h
@@ -327,25 +327,24 @@ template <typename ChannelT, typename FunctionIdT = uint32_t,
           typename SequenceNumberT = uint16_t>
 class RPC : public RPCBase {
 public:
-
   /// RPC default constructor.
   RPC() = default;
 
   /// RPC instances cannot be copied.
-  RPC(const RPC&) = delete;
+  RPC(const RPC &) = delete;
 
   /// RPC instances cannot be copied.
-  RPC& operator=(const RPC&) = delete;
+  RPC &operator=(const RPC &) = delete;
 
   /// RPC move constructor.
   // FIXME: Remove once MSVC can synthesize move ops.
   RPC(RPC &&Other)
-    : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)),
-      OutstandingResults(std::move(Other.OutstandingResults)) {}
+      : SequenceNumberMgr(std::move(Other.SequenceNumberMgr)),
+        OutstandingResults(std::move(Other.OutstandingResults)) {}
 
   /// RPC move assignment.
   // FIXME: Remove once MSVC can synthesize move ops.
-  RPC& operator=(RPC &&Other) {
+  RPC &operator=(RPC &&Other) {
     SequenceNumberMgr = std::move(Other.SequenceNumberMgr);
     OutstandingResults = std::move(Other.OutstandingResults);
     return *this;
@@ -408,7 +407,7 @@ public:
         createOutstandingResult<Func>(std::move(Promise));
 
     if (auto Err = CallHelper<ChannelT, SequenceNumberT, Func>::call(C, SeqNo,
-                                                                    Args...)) {
+                                                                     Args...)) {
       abandonOutstandingResults();
       return std::move(Err);
     } else
@@ -435,7 +434,7 @@ public:
   /// std::future<Optional<T>> (or a future<bool> for void functions).
   template <typename Func, typename... ArgTs>
   Expected<AsyncCallResult<Func>> appendCallAsync(ChannelT &C,
-                                                 const ArgTs &... Args) {
+                                                  const ArgTs &... Args) {
     auto ResAndSeqOrErr = appendCallAsyncWithSeq<Func>(C, Args...);
     if (ResAndSeqOrErr)
       return std::move(ResAndSeqOrErr->first);
@@ -445,7 +444,8 @@ public:
   /// The same as appendCallAsync, except that it calls C.send to flush the
   /// channel after serializing the call.
   template <typename Func, typename... ArgTs>
-  Expected<AsyncCallResult<Func>> callAsync(ChannelT &C, const ArgTs &... Args) {
+  Expected<AsyncCallResult<Func>> callAsync(ChannelT &C,
+                                            const ArgTs &... Args) {
     auto ResAndSeqOrErr = callAsyncWithSeq<Func>(C, Args...);
     if (ResAndSeqOrErr)
       return std::move(ResAndSeqOrErr->first);
diff --git a/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp b/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp
index 4095a3b98ee..b51e3cd002d 100644
--- a/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp
+++ b/lib/ExecutionEngine/Orc/OrcArchitectureSupport.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/Orc/OrcArchitectureSupport.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Support/Process.h"
 
 namespace llvm {
@@ -18,62 +18,62 @@ void OrcX86_64::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn,
                                   void *CallbackMgr) {
 
   const uint8_t ResolverCode[] = {
-                                               // resolver_entry:
-    0x55,                                      // 0x00: pushq     %rbp
-    0x48, 0x89, 0xe5,                          // 0x01: movq      %rsp, %rbp
-    0x50,                                      // 0x04: pushq     %rax
-    0x53,                                      // 0x05: pushq     %rbx
-    0x51,                                      // 0x06: pushq     %rcx
-    0x52,                                      // 0x07: pushq     %rdx
-    0x56,                                      // 0x08: pushq     %rsi
-    0x57,                                      // 0x09: pushq     %rdi
-    0x41, 0x50,                                // 0x0a: pushq     %r8
-    0x41, 0x51,                                // 0x0c: pushq     %r9
-    0x41, 0x52,                                // 0x0e: pushq     %r10
-    0x41, 0x53,                                // 0x10: pushq     %r11
-    0x41, 0x54,                                // 0x12: pushq     %r12
-    0x41, 0x55,                                // 0x14: pushq     %r13
-    0x41, 0x56,                                // 0x16: pushq     %r14
-    0x41, 0x57,                                // 0x18: pushq     %r15
-    0x48, 0x81, 0xec, 0x08, 0x02, 0x00, 0x00,  // 0x1a: subq      0x208, %rsp
-    0x48, 0x0f, 0xae, 0x04, 0x24,              // 0x21: fxsave64  (%rsp)
-    0x48, 0xbf,                                // 0x26: movabsq   <CBMgr>, %rdi
-
-    // 0x28: Callback manager addr.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-
-    0x48, 0x8b, 0x75, 0x08,                    // 0x30: movq      8(%rbp), %rsi
-    0x48, 0x83, 0xee, 0x06,                    // 0x34: subq      $6, %rsi
-    0x48, 0xb8,                                // 0x38: movabsq   <REntry>, %rax
-
-    // 0x3a: JIT re-entry fn addr:
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-
-    0xff, 0xd0,                                // 0x42: callq     *%rax
-    0x48, 0x89, 0x45, 0x08,                    // 0x44: movq      %rax, 8(%rbp)
-    0x48, 0x0f, 0xae, 0x0c, 0x24,              // 0x48: fxrstor64 (%rsp)
-    0x48, 0x81, 0xc4, 0x08, 0x02, 0x00, 0x00,  // 0x4d: addq      0x208, %rsp
-    0x41, 0x5f,                                // 0x54: popq      %r15
-    0x41, 0x5e,                                // 0x56: popq      %r14
-    0x41, 0x5d,                                // 0x58: popq      %r13
-    0x41, 0x5c,                                // 0x5a: popq      %r12
-    0x41, 0x5b,                                // 0x5c: popq      %r11
-    0x41, 0x5a,                                // 0x5e: popq      %r10
-    0x41, 0x59,                                // 0x60: popq      %r9
-    0x41, 0x58,                                // 0x62: popq      %r8
-    0x5f,                                      // 0x64: popq      %rdi
-    0x5e,                                      // 0x65: popq      %rsi
-    0x5a,                                      // 0x66: popq      %rdx
-    0x59,                                      // 0x67: popq      %rcx
-    0x5b,                                      // 0x68: popq      %rbx
-    0x58,                                      // 0x69: popq      %rax
-    0x5d,                                      // 0x6a: popq      %rbp
-    0xc3,                                      // 0x6b: retq
+      // resolver_entry:
+      0x55,                                     // 0x00: pushq     %rbp
+      0x48, 0x89, 0xe5,                         // 0x01: movq      %rsp, %rbp
+      0x50,                                     // 0x04: pushq     %rax
+      0x53,                                     // 0x05: pushq     %rbx
+      0x51,                                     // 0x06: pushq     %rcx
+      0x52,                                     // 0x07: pushq     %rdx
+      0x56,                                     // 0x08: pushq     %rsi
+      0x57,                                     // 0x09: pushq     %rdi
+      0x41, 0x50,                               // 0x0a: pushq     %r8
+      0x41, 0x51,                               // 0x0c: pushq     %r9
+      0x41, 0x52,                               // 0x0e: pushq     %r10
+      0x41, 0x53,                               // 0x10: pushq     %r11
+      0x41, 0x54,                               // 0x12: pushq     %r12
+      0x41, 0x55,                               // 0x14: pushq     %r13
+      0x41, 0x56,                               // 0x16: pushq     %r14
+      0x41, 0x57,                               // 0x18: pushq     %r15
+      0x48, 0x81, 0xec, 0x08, 0x02, 0x00, 0x00, // 0x1a: subq      0x208, %rsp
+      0x48, 0x0f, 0xae, 0x04, 0x24,             // 0x21: fxsave64  (%rsp)
+      0x48, 0xbf,                               // 0x26: movabsq   <CBMgr>, %rdi
+
+      // 0x28: Callback manager addr.
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+      0x48, 0x8b, 0x75, 0x08, // 0x30: movq      8(%rbp), %rsi
+      0x48, 0x83, 0xee, 0x06, // 0x34: subq      $6, %rsi
+      0x48, 0xb8,             // 0x38: movabsq   <REntry>, %rax
+
+      // 0x3a: JIT re-entry fn addr:
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+      0xff, 0xd0,                               // 0x42: callq     *%rax
+      0x48, 0x89, 0x45, 0x08,                   // 0x44: movq      %rax, 8(%rbp)
+      0x48, 0x0f, 0xae, 0x0c, 0x24,             // 0x48: fxrstor64 (%rsp)
+      0x48, 0x81, 0xc4, 0x08, 0x02, 0x00, 0x00, // 0x4d: addq      0x208, %rsp
+      0x41, 0x5f,                               // 0x54: popq      %r15
+      0x41, 0x5e,                               // 0x56: popq      %r14
+      0x41, 0x5d,                               // 0x58: popq      %r13
+      0x41, 0x5c,                               // 0x5a: popq      %r12
+      0x41, 0x5b,                               // 0x5c: popq      %r11
+      0x41, 0x5a,                               // 0x5e: popq      %r10
+      0x41, 0x59,                               // 0x60: popq      %r9
+      0x41, 0x58,                               // 0x62: popq      %r8
+      0x5f,                                     // 0x64: popq      %rdi
+      0x5e,                                     // 0x65: popq      %rsi
+      0x5a,                                     // 0x66: popq      %rdx
+      0x59,                                     // 0x67: popq      %rcx
+      0x5b,                                     // 0x68: popq      %rbx
+      0x58,                                     // 0x69: popq      %rax
+      0x5d,                                     // 0x6a: popq      %rbp
+      0xc3,                                     // 0x6b: retq
   };
 
   const unsigned ReentryFnAddrOffset = 0x3a;
   const unsigned CallbackMgrAddrOffset = 0x28;
-  
+
   memcpy(ResolverMem, ResolverCode, sizeof(ResolverCode));
   memcpy(ResolverMem + ReentryFnAddrOffset, &ReentryFn, sizeof(ReentryFn));
   memcpy(ResolverMem + CallbackMgrAddrOffset, &CallbackMgr,
@@ -81,13 +81,13 @@ void OrcX86_64::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn,
 }
 
 void OrcX86_64::writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
-				 unsigned NumTrampolines) {
+                                 unsigned NumTrampolines) {
 
   unsigned OffsetToPtr = NumTrampolines * TrampolineSize;
 
-  memcpy(TrampolineMem + OffsetToPtr, &ResolverAddr, sizeof(void*));
+  memcpy(TrampolineMem + OffsetToPtr, &ResolverAddr, sizeof(void *));
 
-  uint64_t *Trampolines = reinterpret_cast<uint64_t*>(TrampolineMem);
+  uint64_t *Trampolines = reinterpret_cast<uint64_t *>(TrampolineMem);
   uint64_t CallIndirPCRel = 0xf1c40000000015ff;
 
   for (unsigned I = 0; I < NumTrampolines; ++I, OffsetToPtr -= TrampolineSize)
@@ -126,36 +126,32 @@ Error OrcX86_64::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
-  auto StubsMem =
-    sys::OwningMemoryBlock(
-      sys::Memory::allocateMappedMemory(2 * NumPages * PageSize, nullptr,
-                                        sys::Memory::MF_READ |
-                                        sys::Memory::MF_WRITE,
-                                        EC));
+  auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+      2 * NumPages * PageSize, nullptr,
+      sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
 
   if (EC)
     return errorCodeToError(EC);
 
   // Create separate MemoryBlocks representing the stubs and pointers.
   sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize);
-  sys::MemoryBlock PtrsBlock(static_cast<char*>(StubsMem.base()) +
-                               NumPages * PageSize,
+  sys::MemoryBlock PtrsBlock(static_cast<char *>(StubsMem.base()) +
+                                 NumPages * PageSize,
                              NumPages * PageSize);
 
   // Populate the stubs page stubs and mark it executable.
-  uint64_t *Stub = reinterpret_cast<uint64_t*>(StubsBlock.base());
-  uint64_t PtrOffsetField =
-    static_cast<uint64_t>(NumPages * PageSize - 6) << 16;
+  uint64_t *Stub = reinterpret_cast<uint64_t *>(StubsBlock.base());
+  uint64_t PtrOffsetField = static_cast<uint64_t>(NumPages * PageSize - 6)
+                            << 16;
   for (unsigned I = 0; I < NumStubs; ++I)
     Stub[I] = 0xF1C40000000025ff | PtrOffsetField;
 
-  if (auto EC = sys::Memory::protectMappedMemory(StubsBlock,
-                                                 sys::Memory::MF_READ |
-                                                 sys::Memory::MF_EXEC))
+  if (auto EC = sys::Memory::protectMappedMemory(
+          StubsBlock, sys::Memory::MF_READ | sys::Memory::MF_EXEC))
     return errorCodeToError(EC);
 
   // Initialize all pointers to point at FailureAddress.
-  void **Ptr = reinterpret_cast<void**>(PtrsBlock.base());
+  void **Ptr = reinterpret_cast<void **>(PtrsBlock.base());
   for (unsigned I = 0; I < NumStubs; ++I)
     Ptr[I] = InitialPtrVal;
 
@@ -168,37 +164,38 @@ void OrcI386::writeResolverCode(uint8_t *ResolverMem, JITReentryFn ReentryFn,
                                 void *CallbackMgr) {
 
   const uint8_t ResolverCode[] = {
-                                              // resolver_entry:
-    0x55,                                     // 0x00: pushl    %ebp
-    0x89, 0xe5,                               // 0x01: movl     %esp, %ebp
-    0x54,                                     // 0x03: pushl    %esp
-    0x83, 0xe4, 0xf0,                         // 0x04: andl     $-0x10, %esp
-    0x50,                                     // 0x07: pushl    %eax
-    0x53,                                     // 0x08: pushl    %ebx
-    0x51,                                     // 0x09: pushl    %ecx
-    0x52,                                     // 0x0a: pushl    %edx
-    0x56,                                     // 0x0b: pushl    %esi
-    0x57,                                     // 0x0c: pushl    %edi
-    0x81, 0xec, 0x18, 0x02, 0x00, 0x00,       // 0x0d: subl     $0x218, %esp
-    0x0f, 0xae, 0x44, 0x24, 0x10,             // 0x13: fxsave   0x10(%esp)
-    0x8b, 0x75, 0x04,                         // 0x18: movl     0x4(%ebp), %esi
-    0x83, 0xee, 0x05,                         // 0x1b: subl     $0x5, %esi
-    0x89, 0x74, 0x24, 0x04,                   // 0x1e: movl     %esi, 0x4(%esp)
-    0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, // 0x22: movl     <cbmgr>, (%esp)
-    0xb8, 0x00, 0x00, 0x00, 0x00,             // 0x29: movl     <reentry>, %eax
-    0xff, 0xd0,                               // 0x2e: calll    *%eax
-    0x89, 0x45, 0x04,                         // 0x30: movl     %eax, 0x4(%ebp)
-    0x0f, 0xae, 0x4c, 0x24, 0x10,             // 0x33: fxrstor  0x10(%esp)
-    0x81, 0xc4, 0x18, 0x02, 0x00, 0x00,       // 0x38: addl     $0x218, %esp
-    0x5f,                                     // 0x3e: popl     %edi
-    0x5e,                                     // 0x3f: popl     %esi
-    0x5a,                                     // 0x40: popl     %edx
-    0x59,                                     // 0x41: popl     %ecx
-    0x5b,                                     // 0x42: popl     %ebx
-    0x58,                                     // 0x43: popl     %eax
-    0x8b, 0x65, 0xfc,                         // 0x44: movl     -0x4(%ebp), %esp
-    0x5d,                                     // 0x48: popl     %ebp
-    0xc3                                      // 0x49: retl
+      // resolver_entry:
+      0x55,                               // 0x00: pushl    %ebp
+      0x89, 0xe5,                         // 0x01: movl     %esp, %ebp
+      0x54,                               // 0x03: pushl    %esp
+      0x83, 0xe4, 0xf0,                   // 0x04: andl     $-0x10, %esp
+      0x50,                               // 0x07: pushl    %eax
+      0x53,                               // 0x08: pushl    %ebx
+      0x51,                               // 0x09: pushl    %ecx
+      0x52,                               // 0x0a: pushl    %edx
+      0x56,                               // 0x0b: pushl    %esi
+      0x57,                               // 0x0c: pushl    %edi
+      0x81, 0xec, 0x18, 0x02, 0x00, 0x00, // 0x0d: subl     $0x218, %esp
+      0x0f, 0xae, 0x44, 0x24, 0x10,       // 0x13: fxsave   0x10(%esp)
+      0x8b, 0x75, 0x04,                   // 0x18: movl     0x4(%ebp), %esi
+      0x83, 0xee, 0x05,                   // 0x1b: subl     $0x5, %esi
+      0x89, 0x74, 0x24, 0x04,             // 0x1e: movl     %esi, 0x4(%esp)
+      0xc7, 0x04, 0x24, 0x00, 0x00, 0x00,
+      0x00,                               // 0x22: movl     <cbmgr>, (%esp)
+      0xb8, 0x00, 0x00, 0x00, 0x00,       // 0x29: movl     <reentry>, %eax
+      0xff, 0xd0,                         // 0x2e: calll    *%eax
+      0x89, 0x45, 0x04,                   // 0x30: movl     %eax, 0x4(%ebp)
+      0x0f, 0xae, 0x4c, 0x24, 0x10,       // 0x33: fxrstor  0x10(%esp)
+      0x81, 0xc4, 0x18, 0x02, 0x00, 0x00, // 0x38: addl     $0x218, %esp
+      0x5f,                               // 0x3e: popl     %edi
+      0x5e,                               // 0x3f: popl     %esi
+      0x5a,                               // 0x40: popl     %edx
+      0x59,                               // 0x41: popl     %ecx
+      0x5b,                               // 0x42: popl     %ebx
+      0x58,                               // 0x43: popl     %eax
+      0x8b, 0x65, 0xfc,                   // 0x44: movl     -0x4(%ebp), %esp
+      0x5d,                               // 0x48: popl     %ebp
+      0xc3                                // 0x49: retl
   };
 
   const unsigned ReentryFnAddrOffset = 0x2a;
@@ -216,16 +213,15 @@ void OrcI386::writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
   uint64_t CallRelImm = 0xF1C4C400000000e8;
   uint64_t Resolver = reinterpret_cast<uint64_t>(ResolverAddr);
   uint64_t ResolverRel =
-    Resolver - reinterpret_cast<uint64_t>(TrampolineMem) - 5;
+      Resolver - reinterpret_cast<uint64_t>(TrampolineMem) - 5;
 
-  uint64_t *Trampolines = reinterpret_cast<uint64_t*>(TrampolineMem);
+  uint64_t *Trampolines = reinterpret_cast<uint64_t *>(TrampolineMem);
   for (unsigned I = 0; I < NumTrampolines; ++I, ResolverRel -= TrampolineSize)
     Trampolines[I] = CallRelImm | (ResolverRel << 8);
 }
 
 Error OrcI386::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
-                                      unsigned MinStubs,
-                                      void *InitialPtrVal) {
+                                      unsigned MinStubs, void *InitialPtrVal) {
   // Stub format is:
   //
   // .section __orc_stubs
@@ -255,35 +251,31 @@ Error OrcI386::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
-  auto StubsMem =
-    sys::OwningMemoryBlock(
-      sys::Memory::allocateMappedMemory(2 * NumPages * PageSize, nullptr,
-                                        sys::Memory::MF_READ |
-                                        sys::Memory::MF_WRITE,
-                                        EC));
+  auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+      2 * NumPages * PageSize, nullptr,
+      sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
 
   if (EC)
     return errorCodeToError(EC);
 
   // Create separate MemoryBlocks representing the stubs and pointers.
   sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize);
-  sys::MemoryBlock PtrsBlock(static_cast<char*>(StubsMem.base()) +
-                               NumPages * PageSize,
+  sys::MemoryBlock PtrsBlock(static_cast<char *>(StubsMem.base()) +
+                                 NumPages * PageSize,
                              NumPages * PageSize);
 
   // Populate the stubs page stubs and mark it executable.
-  uint64_t *Stub = reinterpret_cast<uint64_t*>(StubsBlock.base());
+  uint64_t *Stub = reinterpret_cast<uint64_t *>(StubsBlock.base());
   uint64_t PtrAddr = reinterpret_cast<uint64_t>(PtrsBlock.base());
   for (unsigned I = 0; I < NumStubs; ++I, PtrAddr += 4)
     Stub[I] = 0xF1C40000000025ff | (PtrAddr << 16);
 
-  if (auto EC = sys::Memory::protectMappedMemory(StubsBlock,
-                                                 sys::Memory::MF_READ |
-                                                 sys::Memory::MF_EXEC))
+  if (auto EC = sys::Memory::protectMappedMemory(
+          StubsBlock, sys::Memory::MF_READ | sys::Memory::MF_EXEC))
     return errorCodeToError(EC);
 
   // Initialize all pointers to point at FailureAddress.
-  void **Ptr = reinterpret_cast<void**>(PtrsBlock.base());
+  void **Ptr = reinterpret_cast<void **>(PtrsBlock.base());
   for (unsigned I = 0; I < NumStubs; ++I)
     Ptr[I] = InitialPtrVal;
 
diff --git a/lib/ExecutionEngine/Orc/OrcCBindings.cpp b/lib/ExecutionEngine/Orc/OrcCBindings.cpp
index 565a9d03ec9..4153f7f0cc9 100644
--- a/lib/ExecutionEngine/Orc/OrcCBindings.cpp
+++ b/lib/ExecutionEngine/Orc/OrcCBindings.cpp
@@ -19,11 +19,10 @@ LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
 
   auto CompileCallbackMgr = OrcCBindingsStack::createCompileCallbackMgr(T);
   auto IndirectStubsMgrBuilder =
-    OrcCBindingsStack::createIndirectStubsMgrBuilder(T);
+      OrcCBindingsStack::createIndirectStubsMgrBuilder(T);
 
-  OrcCBindingsStack *JITStack =
-    new OrcCBindingsStack(*TM2, std::move(CompileCallbackMgr),
-			  IndirectStubsMgrBuilder);
+  OrcCBindingsStack *JITStack = new OrcCBindingsStack(
+      *TM2, std::move(CompileCallbackMgr), IndirectStubsMgrBuilder);
 
   return wrap(JITStack);
 }
@@ -41,9 +40,7 @@ void LLVMOrcGetMangledSymbol(LLVMOrcJITStackRef JITStack, char **MangledName,
   strcpy(*MangledName, Mangled.c_str());
 }
 
-void LLVMOrcDisposeMangledSymbol(char *MangledName) {
-  delete[] MangledName;
-}
+void LLVMOrcDisposeMangledSymbol(char *MangledName) { delete[] MangledName; }
 
 LLVMOrcTargetAddress
 LLVMOrcCreateLazyCompileCallback(LLVMOrcJITStackRef JITStack,
diff --git a/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp b/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp
index 412e605fc0b..10f6692e9ff 100644
--- a/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp
+++ b/lib/ExecutionEngine/Orc/OrcCBindingsStack.cpp
@@ -20,35 +20,36 @@ using namespace llvm;
 std::unique_ptr<OrcCBindingsStack::CompileCallbackMgr>
 OrcCBindingsStack::createCompileCallbackMgr(Triple T) {
   switch (T.getArch()) {
-    default: return nullptr;
+  default:
+    return nullptr;
 
-    case Triple::x86: {
-      typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
-      return llvm::make_unique<CCMgrT>(0);
-    };
+  case Triple::x86: {
+    typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
+    return llvm::make_unique<CCMgrT>(0);
+  };
 
-    case Triple::x86_64: {
-      typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64> CCMgrT;
-      return llvm::make_unique<CCMgrT>(0);
-    }
+  case Triple::x86_64: {
+    typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64> CCMgrT;
+    return llvm::make_unique<CCMgrT>(0);
+  }
   }
 }
 
 OrcCBindingsStack::IndirectStubsManagerBuilder
 OrcCBindingsStack::createIndirectStubsMgrBuilder(Triple T) {
   switch (T.getArch()) {
-    default: return nullptr;
-
-    case Triple::x86:
-      return [](){
-        return llvm::make_unique<
-                 orc::LocalIndirectStubsManager<orc::OrcI386>>();
-      };
-
-    case Triple::x86_64:
-      return [](){
-        return llvm::make_unique<
-                 orc::LocalIndirectStubsManager<orc::OrcX86_64>>();
-      };
+  default:
+    return nullptr;
+
+  case Triple::x86:
+    return []() {
+      return llvm::make_unique<orc::LocalIndirectStubsManager<orc::OrcI386>>();
+    };
+
+  case Triple::x86_64:
+    return []() {
+      return llvm::make_unique<
+          orc::LocalIndirectStubsManager<orc::OrcX86_64>>();
+    };
   }
 }
diff --git a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
index 6b84c7b523f..508ce62c88d 100644
--- a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
+++ b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
@@ -10,6 +10,7 @@
 #ifndef LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
 #define LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
 
+#include "llvm-c/OrcBindings.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
@@ -18,7 +19,6 @@
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Error.h"
-#include "llvm-c/OrcBindings.h"
 
 namespace llvm {
 
@@ -29,19 +29,18 @@ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
 
 class OrcCBindingsStack {
 public:
-
   typedef orc::JITCompileCallbackManager CompileCallbackMgr;
   typedef orc::ObjectLinkingLayer<> ObjLayerT;
   typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
-  typedef orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr> CODLayerT;
+  typedef orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>
+      CODLayerT;
 
   typedef std::function<std::unique_ptr<CompileCallbackMgr>()>
-    CallbackManagerBuilder;
+      CallbackManagerBuilder;
 
   typedef CODLayerT::IndirectStubsManagerBuilderT IndirectStubsManagerBuilder;
 
 private:
-
   class GenericHandle {
   public:
     virtual ~GenericHandle() {}
@@ -50,20 +49,17 @@ private:
     virtual void removeModule() = 0;
   };
 
-  template <typename LayerT>
-  class GenericHandleImpl : public GenericHandle {
+  template <typename LayerT> class GenericHandleImpl : public GenericHandle {
   public:
     GenericHandleImpl(LayerT &Layer, typename LayerT::ModuleSetHandleT Handle)
-      : Layer(Layer), Handle(std::move(Handle)) {}
+        : Layer(Layer), Handle(std::move(Handle)) {}
 
     orc::JITSymbol findSymbolIn(const std::string &Name,
                                 bool ExportedSymbolsOnly) override {
       return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly);
     }
 
-    void removeModule() override {
-      return Layer.removeModuleSet(Handle);
-    }
+    void removeModule() override { return Layer.removeModuleSet(Handle); }
 
   private:
     LayerT &Layer;
@@ -78,7 +74,6 @@ private:
   }
 
 public:
-
   // We need a 'ModuleSetHandleT' to conform to the layer concept.
   typedef unsigned ModuleSetHandleT;
 
@@ -125,22 +120,20 @@ public:
   createLazyCompileCallback(LLVMOrcLazyCompileCallbackFn Callback,
                             void *CallbackCtx) {
     auto CCInfo = CCMgr->getCompileCallback();
-    CCInfo.setCompileAction(
-      [=]() -> orc::TargetAddress {
-        return Callback(wrap(this), CallbackCtx);
-      });
+    CCInfo.setCompileAction([=]() -> orc::TargetAddress {
+      return Callback(wrap(this), CallbackCtx);
+    });
     return CCInfo.getAddress();
   }
 
-  LLVMOrcErrorCode
-  createIndirectStub(StringRef StubName, orc::TargetAddress Addr) {
+  LLVMOrcErrorCode createIndirectStub(StringRef StubName,
+                                      orc::TargetAddress Addr) {
     return mapError(
-             IndirectStubsMgr->createStub(StubName, Addr,
-                                          JITSymbolFlags::Exported));
+        IndirectStubsMgr->createStub(StubName, Addr, JITSymbolFlags::Exported));
   }
 
-  LLVMOrcErrorCode
-  setIndirectStubPointer(StringRef Name, orc::TargetAddress Addr) {
+  LLVMOrcErrorCode setIndirectStubPointer(StringRef Name,
+                                          orc::TargetAddress Addr) {
     return mapError(IndirectStubsMgr->updatePointer(Name, Addr));
   }
 
@@ -148,36 +141,33 @@ public:
   createResolver(LLVMOrcSymbolResolverFn ExternalResolver,
                  void *ExternalResolverCtx) {
     auto Resolver = orc::createLambdaResolver(
-      [this, ExternalResolver, ExternalResolverCtx](const std::string &Name) {
-        // Search order:
-        // 1. JIT'd symbols.
-        // 2. Runtime overrides.
-        // 3. External resolver (if present).
-
-        if (auto Sym = CODLayer.findSymbol(Name, true))
-          return RuntimeDyld::SymbolInfo(Sym.getAddress(),
-                                         Sym.getFlags());
-        if (auto Sym = CXXRuntimeOverrides.searchOverrides(Name))
-          return Sym;
-
-        if (ExternalResolver)
-          return RuntimeDyld::SymbolInfo(ExternalResolver(Name.c_str(),
-                                                          ExternalResolverCtx),
-                                         llvm::JITSymbolFlags::Exported);
-
-        return RuntimeDyld::SymbolInfo(nullptr);
-      },
-      [](const std::string &Name) {
-        return RuntimeDyld::SymbolInfo(nullptr);
-      }
-    );
+        [this, ExternalResolver, ExternalResolverCtx](const std::string &Name) {
+          // Search order:
+          // 1. JIT'd symbols.
+          // 2. Runtime overrides.
+          // 3. External resolver (if present).
+
+          if (auto Sym = CODLayer.findSymbol(Name, true))
+            return RuntimeDyld::SymbolInfo(Sym.getAddress(), Sym.getFlags());
+          if (auto Sym = CXXRuntimeOverrides.searchOverrides(Name))
+            return Sym;
+
+          if (ExternalResolver)
+            return RuntimeDyld::SymbolInfo(
+                ExternalResolver(Name.c_str(), ExternalResolverCtx),
+                llvm::JITSymbolFlags::Exported);
+
+          return RuntimeDyld::SymbolInfo(nullptr);
+        },
+        [](const std::string &Name) {
+          return RuntimeDyld::SymbolInfo(nullptr);
+        });
 
     return std::shared_ptr<RuntimeDyld::SymbolResolver>(std::move(Resolver));
   }
 
   template <typename LayerT>
-  ModuleHandleT addIRModule(LayerT &Layer,
-                            Module *M,
+  ModuleHandleT addIRModule(LayerT &Layer, Module *M,
                             std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
                             LLVMOrcSymbolResolverFn ExternalResolver,
                             void *ExternalResolverCtx) {
@@ -198,7 +188,7 @@ public:
     auto Resolver = createResolver(ExternalResolver, ExternalResolverCtx);
 
     // Add the module to the JIT.
-    std::vector<Module*> S;
+    std::vector<Module *> S;
     S.push_back(std::move(M));
 
     auto LH = Layer.addModuleSet(std::move(S), std::move(MemMgr),
@@ -215,7 +205,7 @@ public:
     return H;
   }
 
-  ModuleHandleT addIRModuleEager(Module* M,
+  ModuleHandleT addIRModuleEager(Module *M,
                                  LLVMOrcSymbolResolverFn ExternalResolver,
                                  void *ExternalResolverCtx) {
     return addIRModule(CompileLayer, std::move(M),
@@ -223,11 +213,11 @@ public:
                        std::move(ExternalResolver), ExternalResolverCtx);
   }
 
-  ModuleHandleT addIRModuleLazy(Module* M,
+  ModuleHandleT addIRModuleLazy(Module *M,
                                 LLVMOrcSymbolResolverFn ExternalResolver,
                                 void *ExternalResolverCtx) {
     return addIRModule(CODLayer, std::move(M),
-		       llvm::make_unique<SectionMemoryManager>(),
+                       llvm::make_unique<SectionMemoryManager>(),
                        std::move(ExternalResolver), ExternalResolverCtx);
   }
 
@@ -248,12 +238,9 @@ public:
     return GenericHandles[H]->findSymbolIn(Name, ExportedSymbolsOnly);
   }
 
-  const std::string& getErrorMessage() const {
-    return ErrMsg;
-  }
+  const std::string &getErrorMessage() const { return ErrMsg; }
 
 private:
-
   template <typename LayerT>
   unsigned createHandle(LayerT &Layer,
                         typename LayerT::ModuleSetHandleT Handle) {
@@ -272,14 +259,13 @@ private:
 
   LLVMOrcErrorCode mapError(Error Err) {
     LLVMOrcErrorCode Result = LLVMOrcErrSuccess;
-    handleAllErrors(std::move(Err),
-      [&](ErrorInfoBase &EIB) {
-        // Handler of last resort.
-        Result = LLVMOrcErrGeneric;
-        ErrMsg = "";
-        raw_string_ostream ErrStream(ErrMsg);
-        EIB.log(ErrStream);
-      });
+    handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
+      // Handler of last resort.
+      Result = LLVMOrcErrGeneric;
+      ErrMsg = "";
+      raw_string_ostream ErrStream(ErrMsg);
+      EIB.log(ErrStream);
+    });
     return Result;
   }
 
diff --git a/lib/ExecutionEngine/Orc/OrcError.cpp b/lib/ExecutionEngine/Orc/OrcError.cpp
index 37b49903ba7..58889cc7bc1 100644
--- a/lib/ExecutionEngine/Orc/OrcError.cpp
+++ b/lib/ExecutionEngine/Orc/OrcError.cpp
@@ -53,8 +53,8 @@ namespace orc {
 
 Error orcError(OrcErrorCode ErrCode) {
   typedef std::underlying_type<OrcErrorCode>::type UT;
-  return errorCodeToError(std::error_code(static_cast<UT>(ErrCode),
-                                          *OrcErrCat));
+  return errorCodeToError(
+      std::error_code(static_cast<UT>(ErrCode), *OrcErrCat));
 }
 }
 }
diff --git a/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp b/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
index fedf163e4fb..8140a1ff249 100644
--- a/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
+++ b/unittests/ExecutionEngine/Orc/CompileOnDemandLayerTest.cpp
@@ -18,7 +18,8 @@ namespace {
 
 class DummyCallbackManager : public orc::JITCompileCallbackManager {
 public:
-  DummyCallbackManager() : JITCompileCallbackManager(0) { }
+  DummyCallbackManager() : JITCompileCallbackManager(0) {}
+
 public:
   void grow() override { llvm_unreachable("not implemented"); }
 };
@@ -26,7 +27,7 @@ public:
 class DummyStubsManager : public orc::IndirectStubsManager {
 public:
   Error createStub(StringRef StubName, TargetAddress InitAddr,
-                             JITSymbolFlags Flags) override {
+                   JITSymbolFlags Flags) override {
     llvm_unreachable("Not implemented");
   }
 
@@ -42,22 +43,20 @@ public:
     llvm_unreachable("Not implemented");
   }
 
-  Error updatePointer(StringRef Name,
-                                TargetAddress NewAddr) override {
+  Error updatePointer(StringRef Name, TargetAddress NewAddr) override {
     llvm_unreachable("Not implemented");
   }
 };
 
 TEST(CompileOnDemandLayerTest, FindSymbol) {
-  auto MockBaseLayer =
-    createMockBaseLayer<int>(DoNothingAndReturn<int>(0),
-                             DoNothingAndReturn<void>(),
-                             [](const std::string &Name, bool) {
-                               if (Name == "foo")
-                                 return JITSymbol(1, JITSymbolFlags::Exported);
-                               return JITSymbol(nullptr);
-                             },
-                             DoNothingAndReturn<JITSymbol>(nullptr));
+  auto MockBaseLayer = createMockBaseLayer<int>(
+      DoNothingAndReturn<int>(0), DoNothingAndReturn<void>(),
+      [](const std::string &Name, bool) {
+        if (Name == "foo")
+          return JITSymbol(1, JITSymbolFlags::Exported);
+        return JITSymbol(nullptr);
+      },
+      DoNothingAndReturn<JITSymbol>(nullptr));
 
   typedef decltype(MockBaseLayer) MockBaseLayerT;
   DummyCallbackManager CallbackMgr;
@@ -68,8 +67,7 @@ TEST(CompileOnDemandLayerTest, FindSymbol) {
 
   auto Sym = COD.findSymbol("foo", true);
 
-  EXPECT_TRUE(!!Sym)
-    << "CompileOnDemand::findSymbol should call findSymbol in the base layer.";
+  EXPECT_TRUE(!!Sym) << "CompileOnDemand::findSymbol should call findSymbol in "
+                        "the base layer.";
 }
-
 }
diff --git a/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp b/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
index b2680aa7d8a..7d55641e4ce 100644
--- a/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
+++ b/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
@@ -19,7 +19,8 @@ using namespace llvm::orc::remote;
 
 class Queue : public std::queue<char> {
 public:
-  std::mutex& getLock() { return Lock; }
+  std::mutex &getLock() { return Lock; }
+
 private:
   std::mutex Lock;
 };
@@ -27,7 +28,7 @@ private:
 class QueueChannel : public RPCChannel {
 public:
   QueueChannel(Queue &InQueue, Queue &OutQueue)
-    : InQueue(InQueue), OutQueue(OutQueue) {}
+      : InQueue(InQueue), OutQueue(OutQueue) {}
 
   Error readBytes(char *Dst, unsigned Size) override {
     while (Size != 0) {
@@ -60,10 +61,8 @@ private:
   Queue &OutQueue;
 };
 
-class DummyRPC : public testing::Test,
-                 public RPC<QueueChannel> {
+class DummyRPC : public testing::Test, public RPC<QueueChannel> {
 public:
-
   enum FuncId : uint32_t {
     VoidBoolId = RPCFunctionIdTraits<FuncId>::FirstValidId,
     IntIntId,
@@ -72,14 +71,12 @@ public:
 
   typedef Function<VoidBoolId, void(bool)> VoidBool;
   typedef Function<IntIntId, int32_t(int32_t)> IntInt;
-  typedef Function<AllTheTypesId, void(int8_t, uint8_t, int16_t, uint16_t,
-                                       int32_t, uint32_t, int64_t, uint64_t,
-                                       bool, std::string, std::vector<int>)>
-    AllTheTypes;
-
+  typedef Function<AllTheTypesId,
+                   void(int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
+                        int64_t, uint64_t, bool, std::string, std::vector<int>)>
+      AllTheTypes;
 };
 
-
 TEST_F(DummyRPC, TestAsyncVoidBool) {
   Queue Q1, Q2;
   QueueChannel C1(Q1, Q2);
@@ -91,12 +88,10 @@ TEST_F(DummyRPC, TestAsyncVoidBool) {
 
   {
     // Expect a call to Proc1.
-    auto EC = expect<VoidBool>(C2,
-                [&](bool &B) {
-                  EXPECT_EQ(B, true)
-                    << "Bool serialization broken";
-                  return Error::success();
-                });
+    auto EC = expect<VoidBool>(C2, [&](bool &B) {
+      EXPECT_EQ(B, true) << "Bool serialization broken";
+      return Error::success();
+    });
     EXPECT_FALSE(EC) << "Simple expect over queue failed";
   }
 
@@ -122,12 +117,10 @@ TEST_F(DummyRPC, TestAsyncIntInt) {
 
   {
     // Expect a call to Proc1.
-    auto EC = expect<IntInt>(C2,
-                [&](int32_t I) -> Expected<int32_t> {
-                  EXPECT_EQ(I, 21)
-                    << "Bool serialization broken";
-                  return 2 * I;
-                });
+    auto EC = expect<IntInt>(C2, [&](int32_t I) -> Expected<int32_t> {
+      EXPECT_EQ(I, 21) << "Bool serialization broken";
+      return 2 * I;
+    });
     EXPECT_FALSE(EC) << "Simple expect over queue failed";
   }
 
@@ -150,60 +143,32 @@ TEST_F(DummyRPC, TestSerialization) {
 
   // Make a call to Proc1.
   std::vector<int> v({42, 7});
-  auto ResOrErr = callAsyncWithSeq<AllTheTypes>(C1,
-                                                -101,
-                                                250,
-                                                -10000,
-                                                10000,
-                                                -1000000000,
-                                                1000000000,
-                                                -10000000000,
-                                                10000000000,
-                                                true,
-                                                "foo",
-                                                v);
-  EXPECT_TRUE(!!ResOrErr)
-    << "Big (serialization test) call over queue failed";
+  auto ResOrErr = callAsyncWithSeq<AllTheTypes>(
+      C1, -101, 250, -10000, 10000, -1000000000, 1000000000, -10000000000,
+      10000000000, true, "foo", v);
+  EXPECT_TRUE(!!ResOrErr) << "Big (serialization test) call over queue failed";
 
   {
     // Expect a call to Proc1.
-    auto EC = expect<AllTheTypes>(C2,
-                [&](int8_t &s8,
-                    uint8_t &u8,
-                    int16_t &s16,
-                    uint16_t &u16,
-                    int32_t &s32,
-                    uint32_t &u32,
-                    int64_t &s64,
-                    uint64_t &u64,
-                    bool &b,
-                    std::string &s,
-                    std::vector<int> &v) {
-
-                    EXPECT_EQ(s8, -101)
-                      << "int8_t serialization broken";
-                    EXPECT_EQ(u8, 250)
-                      << "uint8_t serialization broken";
-                    EXPECT_EQ(s16, -10000)
-                      << "int16_t serialization broken";
-                    EXPECT_EQ(u16, 10000)
-                      << "uint16_t serialization broken";
-                    EXPECT_EQ(s32, -1000000000)
-                      << "int32_t serialization broken";
-                    EXPECT_EQ(u32, 1000000000ULL)
-                      << "uint32_t serialization broken";
-                    EXPECT_EQ(s64, -10000000000)
-                      << "int64_t serialization broken";
-                    EXPECT_EQ(u64, 10000000000ULL)
-                      << "uint64_t serialization broken";
-                    EXPECT_EQ(b, true)
-                      << "bool serialization broken";
-                    EXPECT_EQ(s, "foo")
-                      << "std::string serialization broken";
-                    EXPECT_EQ(v, std::vector<int>({42, 7}))
-                      << "std::vector serialization broken";
-                    return Error::success();
-                  });
+    auto EC = expect<AllTheTypes>(
+        C2, [&](int8_t &s8, uint8_t &u8, int16_t &s16, uint16_t &u16,
+                int32_t &s32, uint32_t &u32, int64_t &s64, uint64_t &u64,
+                bool &b, std::string &s, std::vector<int> &v) {
+
+          EXPECT_EQ(s8, -101) << "int8_t serialization broken";
+          EXPECT_EQ(u8, 250) << "uint8_t serialization broken";
+          EXPECT_EQ(s16, -10000) << "int16_t serialization broken";
+          EXPECT_EQ(u16, 10000) << "uint16_t serialization broken";
+          EXPECT_EQ(s32, -1000000000) << "int32_t serialization broken";
+          EXPECT_EQ(u32, 1000000000ULL) << "uint32_t serialization broken";
+          EXPECT_EQ(s64, -10000000000) << "int64_t serialization broken";
+          EXPECT_EQ(u64, 10000000000ULL) << "uint64_t serialization broken";
+          EXPECT_EQ(b, true) << "bool serialization broken";
+          EXPECT_EQ(s, "foo") << "std::string serialization broken";
+          EXPECT_EQ(v, std::vector<int>({42, 7}))
+              << "std::vector serialization broken";
+          return Error::success();
+        });
     EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed";
   }