[RuntimeDyld] clang-format files.

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

6 files changed, 580 insertions, 747 deletions

diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
index 5c3cc008e3..b28a312f74 100644
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
@@ -35,11 +35,9 @@ void ObjectImageCommon::anchor() {}
 
 namespace llvm {
 
-void RuntimeDyldImpl::registerEHFrames() {
-}
+void RuntimeDyldImpl::registerEHFrames() {}
 
-void RuntimeDyldImpl::deregisterEHFrames() {
-}
+void RuntimeDyldImpl::deregisterEHFrames() {}
 
 // Resolve the relocations for all symbols we currently know about.
 void RuntimeDyldImpl::resolveRelocations() {
@@ -55,9 +53,8 @@ void RuntimeDyldImpl::resolveRelocations() {
     // symbol for the relocation is located.  The SectionID in the relocation
     // entry provides the section to which the relocation will be applied.
     uint64_t Addr = Sections[i].LoadAddress;
-    DEBUG(dbgs() << "Resolving relocations Section #" << i
-            << "\t" << format("%p", (uint8_t *)Addr)
-            << "\n");
+    DEBUG(dbgs() << "Resolving relocations Section #" << i << "\t"
+                 << format("%p", (uint8_t *)Addr) << "\n");
     resolveRelocationList(Relocations[i], Addr);
     Relocations.erase(i);
   }
@@ -75,7 +72,7 @@ void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
   llvm_unreachable("Attempting to remap address of unknown section!");
 }
 
-ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
+ObjectImage *RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
   MutexGuard locked(lock);
 
   std::unique_ptr<ObjectImage> Obj(InputObject);
@@ -85,7 +82,7 @@ ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
   // Save information about our target
   Arch = (Triple::ArchType)Obj->getArch();
   IsTargetLittleEndian = Obj->getObjectFile()->isLittleEndian();
- 
+
   // Compute the memory size required to load all sections to be loaded
   // and pass this information to the memory manager
   if (MemMgr->needsToReserveAllocationSpace()) {
@@ -93,7 +90,7 @@ ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
     computeTotalAllocSize(*Obj, CodeSize, DataSizeRO, DataSizeRW);
     MemMgr->reserveAllocationSpace(CodeSize, DataSizeRO, DataSizeRW);
   }
-  
+
   // Symbols found in this object
   StringMap<SymbolLoc> LocalSymbols;
   // Used sections from the object file
@@ -134,18 +131,19 @@ ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
         section_iterator SI = Obj->end_sections();
         Check(I->getFileOffset(FileOffset));
         Check(I->getSection(SI));
-        if (SI == Obj->end_sections()) continue;
+        if (SI == Obj->end_sections())
+          continue;
         Check(SI->getContents(SectionData));
         Check(SI->isText(IsCode));
-        const uint8_t* SymPtr = (const uint8_t*)Obj->getData().data() +
-                                (uintptr_t)FileOffset;
-        uintptr_t SectOffset = (uintptr_t)(SymPtr -
-                                           (const uint8_t*)SectionData.begin());
-        unsigned SectionID = findOrEmitSection(*Obj, *SI, IsCode, LocalSections);
+        const uint8_t *SymPtr =
+            (const uint8_t *)Obj->getData().data() + (uintptr_t)FileOffset;
+        uintptr_t SectOffset =
+            (uintptr_t)(SymPtr - (const uint8_t *)SectionData.begin());
+        unsigned SectionID =
+            findOrEmitSection(*Obj, *SI, IsCode, LocalSections);
         LocalSymbols[Name.data()] = SymbolLoc(SectionID, SectOffset);
         DEBUG(dbgs() << "\tFileOffset: " << format("%p", (uintptr_t)FileOffset)
-                     << " flags: " << Flags
-                     << " SID: " << SectionID
+                     << " flags: " << Flags << " SID: " << SectionID
                      << " Offset: " << format("%p", SectOffset));
         GlobalSymbolTable[Name] = SymbolLoc(SectionID, SectOffset);
       }
@@ -171,7 +169,7 @@ ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
     bool IsCode = false;
     Check(RelocatedSection->isText(IsCode));
     SectionID =
-      findOrEmitSection(*Obj, *RelocatedSection, IsCode, LocalSections);
+        findOrEmitSection(*Obj, *RelocatedSection, IsCode, LocalSections);
     DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
 
     for (relocation_iterator I = SI->relocation_begin(),
@@ -187,37 +185,41 @@ ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
 }
 
 // A helper method for computeTotalAllocSize.
-// Computes the memory size required to allocate sections with the given sizes, 
+// Computes the memory size required to allocate sections with the given sizes,
 // assuming that all sections are allocated with the given alignment
-static uint64_t computeAllocationSizeForSections(std::vector<uint64_t>& SectionSizes, 
-                                                 uint64_t Alignment) {
+static uint64_t
+computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
+                                 uint64_t Alignment) {
   uint64_t TotalSize = 0;
   for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
-    uint64_t AlignedSize = (SectionSizes[Idx] + Alignment - 1) / 
-                           Alignment * Alignment;
+    uint64_t AlignedSize =
+        (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
     TotalSize += AlignedSize;
   }
   return TotalSize;
 }
 
-// Compute an upper bound of the memory size that is required to load all sections
-void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj, 
-    uint64_t& CodeSize, uint64_t& DataSizeRO, uint64_t& DataSizeRW) {
+// Compute an upper bound of the memory size that is required to load all
+// sections
+void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj,
+                                            uint64_t &CodeSize,
+                                            uint64_t &DataSizeRO,
+                                            uint64_t &DataSizeRW) {
   // Compute the size of all sections required for execution
   std::vector<uint64_t> CodeSectionSizes;
   std::vector<uint64_t> ROSectionSizes;
   std::vector<uint64_t> RWSectionSizes;
-  uint64_t MaxAlignment = sizeof(void*);
+  uint64_t MaxAlignment = sizeof(void *);
 
-  // Collect sizes of all sections to be loaded; 
+  // Collect sizes of all sections to be loaded;
   // also determine the max alignment of all sections
-  for (section_iterator SI = Obj.begin_sections(), SE = Obj.end_sections(); 
+  for (section_iterator SI = Obj.begin_sections(), SE = Obj.end_sections();
        SI != SE; ++SI) {
     const SectionRef &Section = *SI;
 
     bool IsRequired;
     Check(Section.isRequiredForExecution(IsRequired));
-    
+
     // Consider only the sections that are required to be loaded for execution
     if (IsRequired) {
       uint64_t DataSize = 0;
@@ -230,17 +232,19 @@ void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj,
       Check(Section.isText(IsCode));
       Check(Section.isReadOnlyData(IsReadOnly));
       Check(Section.getName(Name));
-      unsigned Alignment = (unsigned) Alignment64 & 0xffffffffL;
-      
+      unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
+
       uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
       uint64_t SectionSize = DataSize + StubBufSize;
-      
-      // The .eh_frame section (at least on Linux) needs an extra four bytes padded
+
+      // The .eh_frame section (at least on Linux) needs an extra four bytes
+      // padded
       // with zeroes added at the end.  For MachO objects, this section has a
-      // slightly different name, so this won't have any effect for MachO objects.
+      // slightly different name, so this won't have any effect for MachO
+      // objects.
       if (Name == ".eh_frame")
         SectionSize += 4;
-        
+
       if (SectionSize > 0) {
         // save the total size of the section
         if (IsCode) {
@@ -254,14 +258,14 @@ void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj,
         if (Alignment > MaxAlignment) {
           MaxAlignment = Alignment;
         }
-      }      
+      }
     }
   }
 
   // Compute the size of all common symbols
   uint64_t CommonSize = 0;
-  for (symbol_iterator I = Obj.begin_symbols(), E = Obj.end_symbols();
-       I != E; ++I) {
+  for (symbol_iterator I = Obj.begin_symbols(), E = Obj.end_symbols(); I != E;
+       ++I) {
     uint32_t Flags = I->getFlags();
     if (Flags & SymbolRef::SF_Common) {
       // Add the common symbols to a list.  We'll allocate them all below.
@@ -274,29 +278,28 @@ void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj,
     RWSectionSizes.push_back(CommonSize);
   }
 
-  // Compute the required allocation space for each different type of sections 
-  // (code, read-only data, read-write data) assuming that all sections are 
+  // Compute the required allocation space for each different type of sections
+  // (code, read-only data, read-write data) assuming that all sections are
   // allocated with the max alignment. Note that we cannot compute with the
-  // individual alignments of the sections, because then the required size 
+  // individual alignments of the sections, because then the required size
   // depends on the order, in which the sections are allocated.
   CodeSize = computeAllocationSizeForSections(CodeSectionSizes, MaxAlignment);
   DataSizeRO = computeAllocationSizeForSections(ROSectionSizes, MaxAlignment);
-  DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment);   
+  DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment);
 }
 
 // compute stub buffer size for the given section
-unsigned RuntimeDyldImpl::computeSectionStubBufSize(ObjectImage &Obj, 
+unsigned RuntimeDyldImpl::computeSectionStubBufSize(ObjectImage &Obj,
                                                     const SectionRef &Section) {
   unsigned StubSize = getMaxStubSize();
   if (StubSize == 0) {
-     return 0;
+    return 0;
   }
   // FIXME: this is an inefficient way to handle this. We should computed the
   // necessary section allocation size in loadObject by walking all the sections
   // once.
   unsigned StubBufSize = 0;
-  for (section_iterator SI = Obj.begin_sections(),
-                        SE = Obj.end_sections();
+  for (section_iterator SI = Obj.begin_sections(), SE = Obj.end_sections();
        SI != SE; ++SI) {
     section_iterator RelSecI = SI->getRelocatedSection();
     if (!(RelSecI == Section))
@@ -319,7 +322,7 @@ unsigned RuntimeDyldImpl::computeSectionStubBufSize(ObjectImage &Obj,
   unsigned StubAlignment = getStubAlignment();
   unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
   if (StubAlignment > EndAlignment)
-     StubBufSize += StubAlignment - EndAlignment;
+    StubBufSize += StubAlignment - EndAlignment;
   return StubBufSize;
 }
 
@@ -329,22 +332,20 @@ void RuntimeDyldImpl::emitCommonSymbols(ObjectImage &Obj,
                                         SymbolTableMap &SymbolTable) {
   // Allocate memory for the section
   unsigned SectionID = Sections.size();
-  uint8_t *Addr = MemMgr->allocateDataSection(
-    TotalSize, sizeof(void*), SectionID, StringRef(), false);
+  uint8_t *Addr = MemMgr->allocateDataSection(TotalSize, sizeof(void *),
+                                              SectionID, StringRef(), false);
   if (!Addr)
     report_fatal_error("Unable to allocate memory for common symbols!");
   uint64_t Offset = 0;
   Sections.push_back(SectionEntry(StringRef(), Addr, TotalSize, 0));
   memset(Addr, 0, TotalSize);
 
-  DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
-               << " new addr: " << format("%p", Addr)
-               << " DataSize: " << TotalSize
-               << "\n");
+  DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID << " new addr: "
+               << format("%p", Addr) << " DataSize: " << TotalSize << "\n");
 
   // Assign the address of each symbol
   for (CommonSymbolMap::const_iterator it = CommonSymbols.begin(),
-       itEnd = CommonSymbols.end(); it != itEnd; it++) {
+       itEnd = CommonSymbols.end(); it != itEnd; ++it) {
     uint64_t Size = it->second.first;
     uint64_t Align = it->second.second;
     StringRef Name;
@@ -354,8 +355,8 @@ void RuntimeDyldImpl::emitCommonSymbols(ObjectImage &Obj,
       uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
       Addr += AlignOffset;
       Offset += AlignOffset;
-      DEBUG(dbgs() << "Allocating common symbol " << Name << " address " <<
-                      format("%p\n", Addr));
+      DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
+                   << format("%p\n", Addr));
     }
     Obj.updateSymbolAddress(it->first, (uint64_t)Addr);
     SymbolTable[Name.data()] = SymbolLoc(SectionID, Offset);
@@ -365,8 +366,7 @@ void RuntimeDyldImpl::emitCommonSymbols(ObjectImage &Obj,
 }
 
 unsigned RuntimeDyldImpl::emitSection(ObjectImage &Obj,
-                                      const SectionRef &Section,
-                                      bool IsCode) {
+                                      const SectionRef &Section, bool IsCode) {
 
   StringRef data;
   uint64_t Alignment64;
@@ -388,8 +388,8 @@ unsigned RuntimeDyldImpl::emitSection(ObjectImage &Obj,
   Check(Section.isReadOnlyData(IsReadOnly));
   Check(Section.getSize(DataSize));
   Check(Section.getName(Name));
-    
-  StubBufSize = computeSectionStubBufSize(Obj, Section); 
+
+  StubBufSize = computeSectionStubBufSize(Obj, Section);
 
   // The .eh_frame section (at least on Linux) needs an extra four bytes padded
   // with zeroes added at the end.  For MachO objects, this section has a
@@ -406,10 +406,10 @@ unsigned RuntimeDyldImpl::emitSection(ObjectImage &Obj,
   // Leave those where they are.
   if (IsRequired) {
     Allocate = DataSize + PaddingSize + StubBufSize;
-    Addr = IsCode
-      ? MemMgr->allocateCodeSection(Allocate, Alignment, SectionID, Name)
-      : MemMgr->allocateDataSection(Allocate, Alignment, SectionID, Name,
-                                    IsReadOnly);
+    Addr = IsCode ? MemMgr->allocateCodeSection(Allocate, Alignment, SectionID,
+                                                Name)
+                  : MemMgr->allocateDataSection(Allocate, Alignment, SectionID,
+                                                Name, IsReadOnly);
     if (!Addr)
       report_fatal_error("Unable to allocate section memory!");
 
@@ -430,30 +430,22 @@ unsigned RuntimeDyldImpl::emitSection(ObjectImage &Obj,
       DataSize += PaddingSize;
     }
 
-    DEBUG(dbgs() << "emitSection SectionID: " << SectionID
-                 << " Name: " << Name
+    DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
                  << " obj addr: " << format("%p", pData)
                  << " new addr: " << format("%p", Addr)
-                 << " DataSize: " << DataSize
-                 << " StubBufSize: " << StubBufSize
-                 << " Allocate: " << Allocate
-                 << "\n");
+                 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
+                 << " Allocate: " << Allocate << "\n");
     Obj.updateSectionAddress(Section, (uint64_t)Addr);
-  }
-  else {
+  } else {
     // Even if we didn't load the section, we need to record an entry for it
     // to handle later processing (and by 'handle' I mean don't do anything
     // with these sections).
     Allocate = 0;
     Addr = 0;
-    DEBUG(dbgs() << "emitSection SectionID: " << SectionID
-                 << " Name: " << Name
-                 << " obj addr: " << format("%p", data.data())
-                 << " new addr: 0"
-                 << " DataSize: " << DataSize
-                 << " StubBufSize: " << StubBufSize
-                 << " Allocate: " << Allocate
-                 << "\n");
+    DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
+                 << " obj addr: " << format("%p", data.data()) << " new addr: 0"
+                 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
+                 << " Allocate: " << Allocate << "\n");
   }
 
   Sections.push_back(SectionEntry(Name, Addr, DataSize, (uintptr_t)pData));
@@ -486,8 +478,7 @@ void RuntimeDyldImpl::addRelocationForSymbol(const RelocationEntry &RE,
   // Relocation by symbol.  If the symbol is found in the global symbol table,
   // create an appropriate section relocation.  Otherwise, add it to
   // ExternalSymbolRelocations.
-  SymbolTableMap::const_iterator Loc =
-      GlobalSymbolTable.find(SymbolName);
+  SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
   if (Loc == GlobalSymbolTable.end()) {
     ExternalSymbolRelocations[SymbolName].push_back(RE);
   } else {
@@ -503,7 +494,7 @@ uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr) {
     // This stub has to be able to access the full address space,
     // since symbol lookup won't necessarily find a handy, in-range,
     // PLT stub for functions which could be anywhere.
-    uint32_t *StubAddr = (uint32_t*)Addr;
+    uint32_t *StubAddr = (uint32_t *)Addr;
 
     // Stub can use ip0 (== x16) to calculate address
     *StubAddr = 0xd2e00010; // movz ip0, #:abs_g3:<addr>
@@ -520,11 +511,11 @@ uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr) {
   } else if (Arch == Triple::arm) {
     // TODO: There is only ARM far stub now. We should add the Thumb stub,
     // and stubs for branches Thumb - ARM and ARM - Thumb.
-    uint32_t *StubAddr = (uint32_t*)Addr;
+    uint32_t *StubAddr = (uint32_t *)Addr;
     *StubAddr = 0xe51ff004; // ldr pc,<label>
-    return (uint8_t*)++StubAddr;
+    return (uint8_t *)++StubAddr;
   } else if (Arch == Triple::mipsel || Arch == Triple::mips) {
-    uint32_t *StubAddr = (uint32_t*)Addr;
+    uint32_t *StubAddr = (uint32_t *)Addr;
     // 0:   3c190000        lui     t9,%hi(addr).
     // 4:   27390000        addiu   t9,t9,%lo(addr).
     // 8:   03200008        jr      t9.
@@ -602,29 +593,30 @@ void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
 }
 
 void RuntimeDyldImpl::resolveExternalSymbols() {
-  while(!ExternalSymbolRelocations.empty()) {
+  while (!ExternalSymbolRelocations.empty()) {
     StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
 
     StringRef Name = i->first();
     if (Name.size() == 0) {
       // This is an absolute symbol, use an address of zero.
-      DEBUG(dbgs() << "Resolving absolute relocations." << "\n");
+      DEBUG(dbgs() << "Resolving absolute relocations."
+                   << "\n");
       RelocationList &Relocs = i->second;
       resolveRelocationList(Relocs, 0);
     } else {
       uint64_t Addr = 0;
       SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(Name);
       if (Loc == GlobalSymbolTable.end()) {
-          // This is an external symbol, try to get its address from
-          // MemoryManager.
-          Addr = MemMgr->getSymbolAddress(Name.data());
-          // The call to getSymbolAddress may have caused additional modules to
-          // be loaded, which may have added new entries to the
-          // ExternalSymbolRelocations map.  Consquently, we need to update our
-          // iterator.  This is also why retrieval of the relocation list
-          // associated with this symbol is deferred until below this point.
-          // New entries may have been added to the relocation list.
-          i = ExternalSymbolRelocations.find(Name);
+        // This is an external symbol, try to get its address from
+        // MemoryManager.
+        Addr = MemMgr->getSymbolAddress(Name.data());
+        // The call to getSymbolAddress may have caused additional modules to
+        // be loaded, which may have added new entries to the
+        // ExternalSymbolRelocations map.  Consquently, we need to update our
+        // iterator.  This is also why retrieval of the relocation list
+        // associated with this symbol is deferred until below this point.
+        // New entries may have been added to the relocation list.
+        i = ExternalSymbolRelocations.find(Name);
       } else {
         // We found the symbol in our global table.  It was probably in a
         // Module that we loaded previously.
@@ -635,12 +627,11 @@ void RuntimeDyldImpl::resolveExternalSymbols() {
       // FIXME: Implement error handling that doesn't kill the host program!
       if (!Addr)
         report_fatal_error("Program used external function '" + Name +
-                          "' which could not be resolved!");
+                           "' which could not be resolved!");
 
       updateGOTEntries(Name, Addr);
-      DEBUG(dbgs() << "Resolving relocations Name: " << Name
-              << "\t" << format("0x%lx", Addr)
-              << "\n");
+      DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
+                   << format("0x%lx", Addr) << "\n");
       // This list may have been updated when we called getSymbolAddress, so
       // don't change this code to get the list earlier.
       RelocationList &Relocs = i->second;
@@ -651,7 +642,6 @@ void RuntimeDyldImpl::resolveExternalSymbols() {
   }
 }
 
-
 //===----------------------------------------------------------------------===//
 // RuntimeDyld class implementation
 RuntimeDyld::RuntimeDyld(RTDyldMemoryManager *mm) {
@@ -666,21 +656,17 @@ RuntimeDyld::RuntimeDyld(RTDyldMemoryManager *mm) {
   ProcessAllSections = false;
 }
 
-RuntimeDyld::~RuntimeDyld() {
-  delete Dyld;
-}
+RuntimeDyld::~RuntimeDyld() { delete Dyld; }
 
-static std::unique_ptr<RuntimeDyldELF> createRuntimeDyldELF(
-                                                   RTDyldMemoryManager *MM,
-                                                   bool ProcessAllSections) {
+static std::unique_ptr<RuntimeDyldELF>
+createRuntimeDyldELF(RTDyldMemoryManager *MM, bool ProcessAllSections) {
   std::unique_ptr<RuntimeDyldELF> Dyld(new RuntimeDyldELF(MM));
   Dyld->setProcessAllSections(ProcessAllSections);
   return Dyld;
 }
 
-static std::unique_ptr<RuntimeDyldMachO> createRuntimeDyldMachO(
-                                                   RTDyldMemoryManager *MM,
-                                                   bool ProcessAllSections) {
+static std::unique_ptr<RuntimeDyldMachO>
+createRuntimeDyldMachO(RTDyldMemoryManager *MM, bool ProcessAllSections) {
   std::unique_ptr<RuntimeDyldMachO> Dyld(new RuntimeDyldMachO(MM));
   Dyld->setProcessAllSections(ProcessAllSections);
   return Dyld;
@@ -709,8 +695,7 @@ ObjectImage *RuntimeDyld::loadObject(ObjectFile *InputObject) {
 
 ObjectImage *RuntimeDyld::loadObject(ObjectBuffer *InputBuffer) {
   std::unique_ptr<ObjectImage> InputImage;
-  sys::fs::file_magic Type =
-    sys::fs::identify_magic(InputBuffer->getBuffer());
+  sys::fs::file_magic Type = sys::fs::identify_magic(InputBuffer->getBuffer());
 
   switch (Type) {
   case sys::fs::file_magic::elf_relocatable:
@@ -765,12 +750,9 @@ uint64_t RuntimeDyld::getSymbolLoadAddress(StringRef Name) {
   return Dyld->getSymbolLoadAddress(Name);
 }
 
-void RuntimeDyld::resolveRelocations() {
-  Dyld->resolveRelocations();
-}
+void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
 
-void RuntimeDyld::reassignSectionAddress(unsigned SectionID,
-                                         uint64_t Addr) {
+void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
   Dyld->reassignSectionAddress(SectionID, Addr);
 }
 
@@ -779,9 +761,7 @@ void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
   Dyld->mapSectionAddress(LocalAddress, TargetAddress);
 }
 
-StringRef RuntimeDyld::getErrorString() {
-  return Dyld->getErrorString();
-}
+StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
 
 void RuntimeDyld::registerEHFrames() {
   if (Dyld)
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
index 6510bd0a2e..861c9beb1e 100644
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
@@ -31,30 +31,24 @@ using namespace llvm::object;
 
 namespace {
 
-static inline
-error_code check(error_code Err) {
+static inline error_code check(error_code Err) {
   if (Err) {
     report_fatal_error(Err.message());
   }
   return Err;
 }
 
-template<class ELFT>
-class DyldELFObject
-  : public ELFObjectFile<ELFT> {
+template <class ELFT> class DyldELFObject : public ELFObjectFile<ELFT> {
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 
   typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
   typedef Elf_Sym_Impl<ELFT> Elf_Sym;
-  typedef
-    Elf_Rel_Impl<ELFT, false> Elf_Rel;
-  typedef
-    Elf_Rel_Impl<ELFT, true> Elf_Rela;
+  typedef Elf_Rel_Impl<ELFT, false> Elf_Rel;
+  typedef Elf_Rel_Impl<ELFT, true> Elf_Rela;
 
   typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
 
-  typedef typename ELFDataTypeTypedefHelper<
-          ELFT>::value_type addr_type;
+  typedef typename ELFDataTypeTypedefHelper<ELFT>::value_type addr_type;
 
 public:
   DyldELFObject(MemoryBuffer *Wrapper, error_code &ec);
@@ -64,80 +58,74 @@ public:
 
   // Methods for type inquiry through isa, cast and dyn_cast
   static inline bool classof(const Binary *v) {
-    return (isa<ELFObjectFile<ELFT> >(v)
-            && classof(cast<ELFObjectFile
-                <ELFT> >(v)));
+    return (isa<ELFObjectFile<ELFT>>(v) &&
+            classof(cast<ELFObjectFile<ELFT>>(v)));
   }
-  static inline bool classof(
-      const ELFObjectFile<ELFT> *v) {
+  static inline bool classof(const ELFObjectFile<ELFT> *v) {
     return v->isDyldType();
   }
 };
 
-template<class ELFT>
-class ELFObjectImage : public ObjectImageCommon {
-  protected:
-    DyldELFObject<ELFT> *DyldObj;
-    bool Registered;
-
-  public:
-    ELFObjectImage(ObjectBuffer *Input,
-                 DyldELFObject<ELFT> *Obj)
-    : ObjectImageCommon(Input, Obj),
-      DyldObj(Obj),
-      Registered(false) {}
-
-    virtual ~ELFObjectImage() {
-      if (Registered)
-        deregisterWithDebugger();
-    }
+template <class ELFT> class ELFObjectImage : public ObjectImageCommon {
+protected:
+  DyldELFObject<ELFT> *DyldObj;
+  bool Registered;
 
-    // Subclasses can override these methods to update the image with loaded
-    // addresses for sections and common symbols
-    void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) override {
-      DyldObj->updateSectionAddress(Sec, Addr);
-    }
+public:
+  ELFObjectImage(ObjectBuffer *Input, DyldELFObject<ELFT> *Obj)
+      : ObjectImageCommon(Input, Obj), DyldObj(Obj), Registered(false) {}
 
-    void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) override {
-      DyldObj->updateSymbolAddress(Sym, Addr);
-    }
+  virtual ~ELFObjectImage() {
+    if (Registered)
+      deregisterWithDebugger();
+  }
 
-    void registerWithDebugger() override {
-      JITRegistrar::getGDBRegistrar().registerObject(*Buffer);
-      Registered = true;
-    }
-    void deregisterWithDebugger() override {
-      JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer);
-    }
+  // Subclasses can override these methods to update the image with loaded
+  // addresses for sections and common symbols
+  void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) override {
+    DyldObj->updateSectionAddress(Sec, Addr);
+  }
+
+  void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) override {
+    DyldObj->updateSymbolAddress(Sym, Addr);
+  }
+
+  void registerWithDebugger() override {
+    JITRegistrar::getGDBRegistrar().registerObject(*Buffer);
+    Registered = true;
+  }
+  void deregisterWithDebugger() override {
+    JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer);
+  }
 };
 
 // The MemoryBuffer passed into this constructor is just a wrapper around the
 // actual memory.  Ultimately, the Binary parent class will take ownership of
 // this MemoryBuffer object but not the underlying memory.
-template<class ELFT>
+template <class ELFT>
 DyldELFObject<ELFT>::DyldELFObject(MemoryBuffer *Wrapper, error_code &ec)
-  : ELFObjectFile<ELFT>(Wrapper, ec) {
+    : ELFObjectFile<ELFT>(Wrapper, ec) {
   this->isDyldELFObject = true;
 }
 
-template<class ELFT>
+template <class ELFT>
 void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec,
                                                uint64_t Addr) {
   DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
-  Elf_Shdr *shdr = const_cast<Elf_Shdr*>(
-                          reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
+  Elf_Shdr *shdr =
+      const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
 
   // This assumes the address passed in matches the target address bitness
   // The template-based type cast handles everything else.
   shdr->sh_addr = static_cast<addr_type>(Addr);
 }
 
-template<class ELFT>
+template <class ELFT>
 void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef,
                                               uint64_t Addr) {
 
-  Elf_Sym *sym = const_cast<Elf_Sym*>(
-    ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl()));
+  Elf_Sym *sym = const_cast<Elf_Sym *>(
+      ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl()));
 
   // This assumes the address passed in matches the target address bitness
   // The template-based type cast handles everything else.
@@ -175,93 +163,85 @@ void RuntimeDyldELF::deregisterEHFrames() {
   RegisteredEHFrameSections.clear();
 }
 
-ObjectImage *RuntimeDyldELF::createObjectImageFromFile(object::ObjectFile *ObjFile) {
+ObjectImage *
+RuntimeDyldELF::createObjectImageFromFile(object::ObjectFile *ObjFile) {
   if (!ObjFile)
     return NULL;
 
   error_code ec;
-  MemoryBuffer* Buffer = MemoryBuffer::getMemBuffer(ObjFile->getData(), 
-                                                    "", 
-                                                    false);
+  MemoryBuffer *Buffer =
+      MemoryBuffer::getMemBuffer(ObjFile->getData(), "", false);
 
   if (ObjFile->getBytesInAddress() == 4 && ObjFile->isLittleEndian()) {
-    DyldELFObject<ELFType<support::little, 2, false> > *Obj =
-      new DyldELFObject<ELFType<support::little, 2, false> >(Buffer, ec);
-    return new ELFObjectImage<ELFType<support::little, 2, false> >(NULL, Obj);
-  }
-  else if (ObjFile->getBytesInAddress() == 4 && !ObjFile->isLittleEndian()) {
-    DyldELFObject<ELFType<support::big, 2, false> > *Obj =
-      new DyldELFObject<ELFType<support::big, 2, false> >(Buffer, ec);
-    return new ELFObjectImage<ELFType<support::big, 2, false> >(NULL, Obj);
-  }
-  else if (ObjFile->getBytesInAddress() == 8 && !ObjFile->isLittleEndian()) {
-    DyldELFObject<ELFType<support::big, 2, true> > *Obj =
-      new DyldELFObject<ELFType<support::big, 2, true> >(Buffer, ec);
-    return new ELFObjectImage<ELFType<support::big, 2, true> >(NULL, Obj);
-  }
-  else if (ObjFile->getBytesInAddress() == 8 && ObjFile->isLittleEndian()) {
-    DyldELFObject<ELFType<support::little, 2, true> > *Obj =
-      new DyldELFObject<ELFType<support::little, 2, true> >(Buffer, ec);
-    return new ELFObjectImage<ELFType<support::little, 2, true> >(NULL, Obj);
-  }
-  else
+    DyldELFObject<ELFType<support::little, 2, false>> *Obj =
+        new DyldELFObject<ELFType<support::little, 2, false>>(Buffer, ec);
+    return new ELFObjectImage<ELFType<support::little, 2, false>>(NULL, Obj);
+  } else if (ObjFile->getBytesInAddress() == 4 && !ObjFile->isLittleEndian()) {
+    DyldELFObject<ELFType<support::big, 2, false>> *Obj =
+        new DyldELFObject<ELFType<support::big, 2, false>>(Buffer, ec);
+    return new ELFObjectImage<ELFType<support::big, 2, false>>(NULL, Obj);
+  } else if (ObjFile->getBytesInAddress() == 8 && !ObjFile->isLittleEndian()) {
+    DyldELFObject<ELFType<support::big, 2, true>> *Obj =
+        new DyldELFObject<ELFType<support::big, 2, true>>(Buffer, ec);
+    return new ELFObjectImage<ELFType<support::big, 2, true>>(NULL, Obj);
+  } else if (ObjFile->getBytesInAddress() == 8 && ObjFile->isLittleEndian()) {
+    DyldELFObject<ELFType<support::little, 2, true>> *Obj =
+        new DyldELFObject<ELFType<support::little, 2, true>>(Buffer, ec);
+    return new ELFObjectImage<ELFType<support::little, 2, true>>(NULL, Obj);
+  } else
     llvm_unreachable("Unexpected ELF format");
 }
 
 ObjectImage *RuntimeDyldELF::createObjectImage(ObjectBuffer *Buffer) {
   if (Buffer->getBufferSize() < ELF::EI_NIDENT)
     llvm_unreachable("Unexpected ELF object size");
-  std::pair<unsigned char, unsigned char> Ident = std::make_pair(
-                         (uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS],
-                         (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]);
+  std::pair<unsigned char, unsigned char> Ident =
+      std::make_pair((uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS],
+                     (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]);
   error_code ec;
 
   if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) {
-    DyldELFObject<ELFType<support::little, 4, false> > *Obj =
-      new DyldELFObject<ELFType<support::little, 4, false> >(
-        Buffer->getMemBuffer(), ec);
-    return new ELFObjectImage<ELFType<support::little, 4, false> >(Buffer, Obj);
-  }
-  else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB) {
-    DyldELFObject<ELFType<support::big, 4, false> > *Obj =
-      new DyldELFObject<ELFType<support::big, 4, false> >(
-        Buffer->getMemBuffer(), ec);
-    return new ELFObjectImage<ELFType<support::big, 4, false> >(Buffer, Obj);
-  }
-  else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB) {
-    DyldELFObject<ELFType<support::big, 8, true> > *Obj =
-      new DyldELFObject<ELFType<support::big, 8, true> >(
-        Buffer->getMemBuffer(), ec);
-    return new ELFObjectImage<ELFType<support::big, 8, true> >(Buffer, Obj);
-  }
-  else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) {
-    DyldELFObject<ELFType<support::little, 8, true> > *Obj =
-      new DyldELFObject<ELFType<support::little, 8, true> >(
-        Buffer->getMemBuffer(), ec);
-    return new ELFObjectImage<ELFType<support::little, 8, true> >(Buffer, Obj);
-  }
-  else
+    DyldELFObject<ELFType<support::little, 4, false>> *Obj =
+        new DyldELFObject<ELFType<support::little, 4, false>>(
+            Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<ELFType<support::little, 4, false>>(Buffer, Obj);
+  } else if (Ident.first == ELF::ELFCLASS32 &&
+             Ident.second == ELF::ELFDATA2MSB) {
+    DyldELFObject<ELFType<support::big, 4, false>> *Obj =
+        new DyldELFObject<ELFType<support::big, 4, false>>(
+            Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<ELFType<support::big, 4, false>>(Buffer, Obj);
+  } else if (Ident.first == ELF::ELFCLASS64 &&
+             Ident.second == ELF::ELFDATA2MSB) {
+    DyldELFObject<ELFType<support::big, 8, true>> *Obj =
+        new DyldELFObject<ELFType<support::big, 8, true>>(
+            Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<ELFType<support::big, 8, true>>(Buffer, Obj);
+  } else if (Ident.first == ELF::ELFCLASS64 &&
+             Ident.second == ELF::ELFDATA2LSB) {
+    DyldELFObject<ELFType<support::little, 8, true>> *Obj =
+        new DyldELFObject<ELFType<support::little, 8, true>>(
+            Buffer->getMemBuffer(), ec);
+    return new ELFObjectImage<ELFType<support::little, 8, true>>(Buffer, Obj);
+  } else
     llvm_unreachable("Unexpected ELF format");
 }
 
-RuntimeDyldELF::~RuntimeDyldELF() {
-}
+RuntimeDyldELF::~RuntimeDyldELF() {}
 
 void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
-                                             uint64_t Offset,
-                                             uint64_t Value,
-                                             uint32_t Type,
-                                             int64_t  Addend,
+                                             uint64_t Offset, uint64_t Value,
+                                             uint32_t Type, int64_t Addend,
                                              uint64_t SymOffset) {
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
-  break;
+    break;
   case ELF::R_X86_64_64: {
-    uint64_t *Target = reinterpret_cast<uint64_t*>(Section.Address + Offset);
+    uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset);
     *Target = Value + Addend;
-    DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend))
-                 << " at " << format("%p\n",Target));
+    DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
+                 << format("%p\n", Target));
     break;
   }
   case ELF::R_X86_64_32:
@@ -269,20 +249,20 @@ void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
     Value += Addend;
     assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) ||
            (Type == ELF::R_X86_64_32S &&
-             ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
+            ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
     uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
-    uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
+    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
     *Target = TruncatedAddr;
-    DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr)
-                 << " at " << format("%p\n",Target));
+    DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
+                 << format("%p\n", Target));
     break;
   }
   case ELF::R_X86_64_GOTPCREL: {
     // findGOTEntry returns the 'G + GOT' part of the relocation calculation
     // based on the load/target address of the GOT (not the current/local addr).
     uint64_t GOTAddr = findGOTEntry(Value, SymOffset);
-    uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
-    uint64_t  FinalAddress = Section.LoadAddress + Offset;
+    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
+    uint64_t FinalAddress = Section.LoadAddress + Offset;
     // The processRelocationRef method combines the symbol offset and the addend
     // and in most cases that's what we want.  For this relocation type, we need
     // the raw addend, so we subtract the symbol offset to get it.
@@ -295,10 +275,10 @@ void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
   case ELF::R_X86_64_PC32: {
     // Get the placeholder value from the generated object since
     // a previous relocation attempt may have overwritten the loaded version
-    uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress
-                                                                   + Offset);
-    uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
-    uint64_t  FinalAddress = Section.LoadAddress + Offset;
+    uint32_t *Placeholder =
+        reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
+    uint64_t FinalAddress = Section.LoadAddress + Offset;
     int64_t RealOffset = *Placeholder + Value + Addend - FinalAddress;
     assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN);
     int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
@@ -308,10 +288,10 @@ void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
   case ELF::R_X86_64_PC64: {
     // Get the placeholder value from the generated object since
     // a previous relocation attempt may have overwritten the loaded version
-    uint64_t *Placeholder = reinterpret_cast<uint64_t*>(Section.ObjAddress
-                                                                   + Offset);
-    uint64_t *Target = reinterpret_cast<uint64_t*>(Section.Address + Offset);
-    uint64_t  FinalAddress = Section.LoadAddress + Offset;
+    uint64_t *Placeholder =
+        reinterpret_cast<uint64_t *>(Section.ObjAddress + Offset);
+    uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset);
+    uint64_t FinalAddress = Section.LoadAddress + Offset;
     *Target = *Placeholder + Value + Addend - FinalAddress;
     break;
   }
@@ -319,53 +299,48 @@ void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
 }
 
 void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section,
-                                          uint64_t Offset,
-                                          uint32_t Value,
-                                          uint32_t Type,
-                                          int32_t Addend) {
+                                          uint64_t Offset, uint32_t Value,
+                                          uint32_t Type, int32_t Addend) {
   switch (Type) {
   case ELF::R_386_32: {
     // Get the placeholder value from the generated object since
     // a previous relocation attempt may have overwritten the loaded version
-    uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress
-                                                                   + Offset);
-    uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
+    uint32_t *Placeholder =
+        reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
     *Target = *Placeholder + Value + Addend;
     break;
   }
   case ELF::R_386_PC32: {
     // Get the placeholder value from the generated object since
     // a previous relocation attempt may have overwritten the loaded version
-    uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress
-                                                                   + Offset);
-    uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
-    uint32_t  FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
+    uint32_t *Placeholder =
+        reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
+    uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
     uint32_t RealOffset = *Placeholder + Value + Addend - FinalAddress;
     *Target = RealOffset;
     break;
-    }
-    default:
-      // There are other relocation types, but it appears these are the
-      // only ones currently used by the LLVM ELF object writer
-      llvm_unreachable("Relocation type not implemented yet!");
-      break;
+  }
+  default:
+    // There are other relocation types, but it appears these are the
+    // only ones currently used by the LLVM ELF object writer
+    llvm_unreachable("Relocation type not implemented yet!");
+    break;
   }
 }
 
 void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
-                                              uint64_t Offset,
-                                              uint64_t Value,
-                                              uint32_t Type,
-                                              int64_t Addend) {
-  uint32_t *TargetPtr = reinterpret_cast<uint32_t*>(Section.Address + Offset);
+                                              uint64_t Offset, uint64_t Value,
+                                              uint32_t Type, int64_t Addend) {
+  uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address + Offset);
   uint64_t FinalAddress = Section.LoadAddress + Offset;
 
   DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x"
                << format("%llx", Section.Address + Offset)
-               << " FinalAddress: 0x" << format("%llx",FinalAddress)
-               << " Value: 0x" << format("%llx",Value)
-               << " Type: 0x" << format("%x",Type)
-               << " Addend: 0x" << format("%llx",Addend)
+               << " FinalAddress: 0x" << format("%llx", FinalAddress)
+               << " Value: 0x" << format("%llx", Value) << " Type: 0x"
+               << format("%x", Type) << " Addend: 0x" << format("%llx", Addend)
                << "\n");
 
   switch (Type) {
@@ -373,7 +348,8 @@ void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_AARCH64_ABS64: {
-    uint64_t *TargetPtr = reinterpret_cast<uint64_t*>(Section.Address + Offset);
+    uint64_t *TargetPtr =
+        reinterpret_cast<uint64_t *>(Section.Address + Offset);
     *TargetPtr = Value + Addend;
     break;
   }
@@ -451,7 +427,8 @@ void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
   }
   case ELF::R_AARCH64_ADR_PREL_PG_HI21: {
     // Operation: Page(S+A) - Page(P)
-    uint64_t Result = ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
+    uint64_t Result =
+        ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
 
     // Check that -2^32 <= X < 2^32
     assert(static_cast<int64_t>(Result) >= (-1LL << 32) &&
@@ -495,26 +472,22 @@ void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
 }
 
 void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
-                                          uint64_t Offset,
-                                          uint32_t Value,
-                                          uint32_t Type,
-                                          int32_t Addend) {
+                                          uint64_t Offset, uint32_t Value,
+                                          uint32_t Type, int32_t Addend) {
   // TODO: Add Thumb relocations.
-  uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress +
-                                                      Offset);
-  uint32_t* TargetPtr = (uint32_t*)(Section.Address + Offset);
+  uint32_t *Placeholder =
+      reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+  uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset);
   uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
   Value += Addend;
 
   DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: "
                << Section.Address + Offset
-               << " FinalAddress: " << format("%p",FinalAddress)
-               << " Value: " << format("%x",Value)
-               << " Type: " << format("%x",Type)
-               << " Addend: " << format("%x",Addend)
-               << "\n");
+               << " FinalAddress: " << format("%p", FinalAddress) << " Value: "
+               << format("%x", Value) << " Type: " << format("%x", Type)
+               << " Addend: " << format("%x", Addend) << "\n");
 
-  switch(Type) {
+  switch (Type) {
   default:
     llvm_unreachable("Not implemented relocation type!");
 
@@ -550,8 +523,8 @@ void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
     *TargetPtr |= ((Value >> 12) & 0xF) << 16;
     break;
   // Write 24 bit relative value to the branch instruction.
-  case ELF::R_ARM_PC24 :    // Fall through.
-  case ELF::R_ARM_CALL :    // Fall through.
+  case ELF::R_ARM_PC24: // Fall through.
+  case ELF::R_ARM_CALL: // Fall through.
   case ELF::R_ARM_JUMP24: {
     int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8);
     RelValue = (RelValue & 0x03FFFFFC) >> 2;
@@ -571,25 +544,20 @@ void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
 }
 
 void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section,
-                                           uint64_t Offset,
-                                           uint32_t Value,
-                                           uint32_t Type,
-                                           int32_t Addend) {
-  uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress +
-                                                      Offset);
-  uint32_t* TargetPtr = (uint32_t*)(Section.Address + Offset);
+                                           uint64_t Offset, uint32_t Value,
+                                           uint32_t Type, int32_t Addend) {
+  uint32_t *Placeholder =
+      reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+  uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset);
   Value += Addend;
 
   DEBUG(dbgs() << "resolveMipselocation, LocalAddress: "
-               << Section.Address + Offset
-               << " FinalAddress: "
-               << format("%p",Section.LoadAddress + Offset)
-               << " Value: " << format("%x",Value)
-               << " Type: " << format("%x",Type)
-               << " Addend: " << format("%x",Addend)
-               << "\n");
+               << Section.Address + Offset << " FinalAddress: "
+               << format("%p", Section.LoadAddress + Offset) << " Value: "
+               << format("%x", Value) << " Type: " << format("%x", Type)
+               << " Addend: " << format("%x", Addend) << "\n");
 
-  switch(Type) {
+  switch (Type) {
   default:
     llvm_unreachable("Not implemented relocation type!");
     break;
@@ -597,13 +565,13 @@ void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section,
     *TargetPtr = Value + (*Placeholder);
     break;
   case ELF::R_MIPS_26:
-    *TargetPtr = ((*Placeholder) & 0xfc000000) | (( Value & 0x0fffffff) >> 2);
+    *TargetPtr = ((*Placeholder) & 0xfc000000) | ((Value & 0x0fffffff) >> 2);
     break;
   case ELF::R_MIPS_HI16:
     // Get the higher 16-bits. Also add 1 if bit 15 is 1.
     Value += ((*Placeholder) & 0x0000ffff) << 16;
-    *TargetPtr = ((*Placeholder) & 0xffff0000) |
-                 (((Value + 0x8000) >> 16) & 0xffff);
+    *TargetPtr =
+        ((*Placeholder) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
     break;
   case ELF::R_MIPS_LO16:
     Value += ((*Placeholder) & 0x0000ffff);
@@ -614,13 +582,13 @@ void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section,
     // are used for internal JIT purpose. These relocations are similar to
     // R_MIPS_HI16 and R_MIPS_LO16, but they do not take any addend into
     // account.
-    *TargetPtr = ((*TargetPtr) & 0xffff0000) |
-                 (((Value + 0x8000) >> 16) & 0xffff);
+    *TargetPtr =
+        ((*TargetPtr) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
     break;
   case ELF::R_MIPS_UNUSED2:
     *TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff);
     break;
-   }
+  }
 }
 
 // Return the .TOC. section address to R_PPC64_TOC relocations.
@@ -630,9 +598,7 @@ uint64_t RuntimeDyldELF::findPPC64TOC() const {
   SectionList::const_iterator it = Sections.begin();
   SectionList::const_iterator ite = Sections.end();
   for (; it != ite; ++it) {
-    if (it->Name == ".got" ||
-        it->Name == ".toc" ||
-        it->Name == ".tocbss" ||
+    if (it->Name == ".got" || it->Name == ".toc" || it->Name == ".tocbss" ||
         it->Name == ".plt")
       break;
   }
@@ -645,7 +611,7 @@ uint64_t RuntimeDyldELF::findPPC64TOC() const {
     // directly.
     it = Sections.begin();
   }
-  assert (it != ite);
+  assert(it != ite);
   // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
   // thus permitting a full 64 Kbytes segment.
   return it->LoadAddress + 0x8000;
@@ -670,7 +636,8 @@ void RuntimeDyldELF::findOPDEntrySection(ObjectImage &Obj,
       continue;
 
     for (relocation_iterator i = si->relocation_begin(),
-         e = si->relocation_end(); i != e;) {
+                             e = si->relocation_end();
+         i != e;) {
       // The R_PPC64_ADDR64 relocation indicates the first field
       // of a .opd entry
       uint64_t TypeFunc;
@@ -718,65 +685,53 @@ void RuntimeDyldELF::findOPDEntrySection(ObjectImage &Obj,
 // and #highest(value) macros defined in section 4.5.1. Relocation Types
 // in PPC-elf64abi document.
 //
-static inline
-uint16_t applyPPClo (uint64_t value)
-{
-  return value & 0xffff;
-}
+static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; }
 
-static inline
-uint16_t applyPPChi (uint64_t value)
-{
+static inline uint16_t applyPPChi(uint64_t value) {
   return (value >> 16) & 0xffff;
 }
 
-static inline
-uint16_t applyPPChigher (uint64_t value)
-{
+static inline uint16_t applyPPChigher(uint64_t value) {
   return (value >> 32) & 0xffff;
 }
 
-static inline
-uint16_t applyPPChighest (uint64_t value)
-{
+static inline uint16_t applyPPChighest(uint64_t value) {
   return (value >> 48) & 0xffff;
 }
 
 void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
-                                            uint64_t Offset,
-                                            uint64_t Value,
-                                            uint32_t Type,
-                                            int64_t Addend) {
-  uint8_t* LocalAddress = Section.Address + Offset;
+                                            uint64_t Offset, uint64_t Value,
+                                            uint32_t Type, int64_t Addend) {
+  uint8_t *LocalAddress = Section.Address + Offset;
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
-  break;
-  case ELF::R_PPC64_ADDR16_LO :
-    writeInt16BE(LocalAddress, applyPPClo (Value + Addend));
     break;
-  case ELF::R_PPC64_ADDR16_HI :
-    writeInt16BE(LocalAddress, applyPPChi (Value + Addend));
+  case ELF::R_PPC64_ADDR16_LO:
+    writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
+    break;
+  case ELF::R_PPC64_ADDR16_HI:
+    writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
     break;
-  case ELF::R_PPC64_ADDR16_HIGHER :
-    writeInt16BE(LocalAddress, applyPPChigher (Value + Addend));
+  case ELF::R_PPC64_ADDR16_HIGHER:
+    writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
     break;
-  case ELF::R_PPC64_ADDR16_HIGHEST :
-    writeInt16BE(LocalAddress, applyPPChighest (Value + Addend));
+  case ELF::R_PPC64_ADDR16_HIGHEST:
+    writeInt16BE(LocalAddress, applyPPChighest(Value + Addend));
     break;
-  case ELF::R_PPC64_ADDR14 : {
+  case ELF::R_PPC64_ADDR14: {
     assert(((Value + Addend) & 3) == 0);
     // Preserve the AA/LK bits in the branch instruction
-    uint8_t aalk = *(LocalAddress+3);
+    uint8_t aalk = *(LocalAddress + 3);
     writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
   } break;
-  case ELF::R_PPC64_ADDR32 : {
+  case ELF::R_PPC64_ADDR32: {
     int32_t Result = static_cast<int32_t>(Value + Addend);
     if (SignExtend32<32>(Result) != Result)
       llvm_unreachable("Relocation R_PPC64_ADDR32 overflow");
     writeInt32BE(LocalAddress, Result);
   } break;
-  case ELF::R_PPC64_REL24 : {
+  case ELF::R_PPC64_REL24: {
     uint64_t FinalAddress = (Section.LoadAddress + Offset);
     int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
     if (SignExtend32<24>(delta) != delta)
@@ -784,7 +739,7 @@ void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
     // Generates a 'bl <address>' instruction
     writeInt32BE(LocalAddress, 0x48000001 | (delta & 0x03FFFFFC));
   } break;
-  case ELF::R_PPC64_REL32 : {
+  case ELF::R_PPC64_REL32: {
     uint64_t FinalAddress = (Section.LoadAddress + Offset);
     int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
     if (SignExtend32<32>(delta) != delta)
@@ -796,18 +751,18 @@ void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
     uint64_t Delta = Value - FinalAddress + Addend;
     writeInt64BE(LocalAddress, Delta);
   } break;
-  case ELF::R_PPC64_ADDR64 :
+  case ELF::R_PPC64_ADDR64:
     writeInt64BE(LocalAddress, Value + Addend);
     break;
-  case ELF::R_PPC64_TOC :
+  case ELF::R_PPC64_TOC:
     writeInt64BE(LocalAddress, findPPC64TOC());
     break;
-  case ELF::R_PPC64_TOC16 : {
+  case ELF::R_PPC64_TOC16: {
     uint64_t TOCStart = findPPC64TOC();
     Value = applyPPClo((Value + Addend) - TOCStart);
     writeInt16BE(LocalAddress, applyPPClo(Value));
   } break;
-  case ELF::R_PPC64_TOC16_DS : {
+  case ELF::R_PPC64_TOC16_DS: {
     uint64_t TOCStart = findPPC64TOC();
     Value = ((Value + Addend) - TOCStart);
     writeInt16BE(LocalAddress, applyPPClo(Value));
@@ -816,10 +771,8 @@ void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
 }
 
 void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,
-                                              uint64_t Offset,
-                                              uint64_t Value,
-                                              uint32_t Type,
-                                              int64_t Addend) {
+                                              uint64_t Offset, uint64_t Value,
+                                              uint32_t Type, int64_t Addend) {
   uint8_t *LocalAddress = Section.Address + Offset;
   switch (Type) {
   default:
@@ -879,53 +832,46 @@ void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE,
 }
 
 void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
-                                       uint64_t Offset,
-                                       uint64_t Value,
-                                       uint32_t Type,
-                                       int64_t  Addend,
+                                       uint64_t Offset, uint64_t Value,
+                                       uint32_t Type, int64_t Addend,
                                        uint64_t SymOffset) {
   switch (Arch) {
   case Triple::x86_64:
     resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
     break;
   case Triple::x86:
-    resolveX86Relocation(Section, Offset,
-                         (uint32_t)(Value & 0xffffffffL), Type,
+    resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
                          (uint32_t)(Addend & 0xffffffffL));
     break;
   case Triple::aarch64:
     resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
     break;
-  case Triple::arm:    // Fall through.
+  case Triple::arm: // Fall through.
   case Triple::thumb:
-    resolveARMRelocation(Section, Offset,
-                         (uint32_t)(Value & 0xffffffffL), Type,
+    resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
                          (uint32_t)(Addend & 0xffffffffL));
     break;
-  case Triple::mips:    // Fall through.
+  case Triple::mips: // Fall through.
   case Triple::mipsel:
-    resolveMIPSRelocation(Section, Offset,
-                          (uint32_t)(Value & 0xffffffffL), Type,
-                          (uint32_t)(Addend & 0xffffffffL));
+    resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL),
+                          Type, (uint32_t)(Addend & 0xffffffffL));
     break;
-  case Triple::ppc64:   // Fall through.
+  case Triple::ppc64: // Fall through.
   case Triple::ppc64le:
     resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
     break;
   case Triple::systemz:
     resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
     break;
-  default: llvm_unreachable("Unsupported CPU type!");
+  default:
+    llvm_unreachable("Unsupported CPU type!");
   }
 }
 
-relocation_iterator
-RuntimeDyldELF::processRelocationRef(unsigned SectionID,
-                                     relocation_iterator RelI,
-                                     ObjectImage &Obj,
-                                     ObjSectionToIDMap &ObjSectionToID,
-                                     const SymbolTableMap &Symbols,
-                                     StubMap &Stubs) {
+relocation_iterator RuntimeDyldELF::processRelocationRef(
+    unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
+    ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols,
+    StubMap &Stubs) {
   uint64_t RelType;
   Check(RelI->getType(RelType));
   int64_t Addend;
@@ -936,10 +882,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
   StringRef TargetName;
   if (Symbol != Obj.end_symbols())
     Symbol->getName(TargetName);
-  DEBUG(dbgs() << "\t\tRelType: " << RelType
-               << " Addend: " << Addend
-               << " TargetName: " << TargetName
-               << "\n");
+  DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend
+               << " TargetName: " << TargetName << "\n");
   RelocationValueRef Value;
   // First search for the symbol in the local symbol table
   SymbolTableMap::const_iterator lsi = Symbols.end();
@@ -963,53 +907,48 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
       Value.Addend = gsi->second.second + Addend;
     } else {
       switch (SymType) {
-        case SymbolRef::ST_Debug: {
-          // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
-          // and can be changed by another developers. Maybe best way is add
-          // a new symbol type ST_Section to SymbolRef and use it.
-          section_iterator si(Obj.end_sections());
-          Symbol->getSection(si);
-          if (si == Obj.end_sections())
-            llvm_unreachable("Symbol section not found, bad object file format!");
-          DEBUG(dbgs() << "\t\tThis is section symbol\n");
-          // Default to 'true' in case isText fails (though it never does).
-          bool isCode = true;
-          si->isText(isCode);
-          Value.SectionID = findOrEmitSection(Obj,
-                                              (*si),
-                                              isCode,
-                                              ObjSectionToID);
-          Value.Addend = Addend;
-          break;
-        }
-        case SymbolRef::ST_Data:
-        case SymbolRef::ST_Unknown: {
-          Value.SymbolName = TargetName.data();
-          Value.Addend = Addend;
-
-          // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
-          // will manifest here as a NULL symbol name.
-          // We can set this as a valid (but empty) symbol name, and rely
-          // on addRelocationForSymbol to handle this.
-          if (!Value.SymbolName)
-              Value.SymbolName = "";
-          break;
-        }
-        default:
-          llvm_unreachable("Unresolved symbol type!");
-          break;
+      case SymbolRef::ST_Debug: {
+        // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
+        // and can be changed by another developers. Maybe best way is add
+        // a new symbol type ST_Section to SymbolRef and use it.
+        section_iterator si(Obj.end_sections());
+        Symbol->getSection(si);
+        if (si == Obj.end_sections())
+          llvm_unreachable("Symbol section not found, bad object file format!");
+        DEBUG(dbgs() << "\t\tThis is section symbol\n");
+        // Default to 'true' in case isText fails (though it never does).
+        bool isCode = true;
+        si->isText(isCode);
+        Value.SectionID = findOrEmitSection(Obj, (*si), isCode, ObjSectionToID);
+        Value.Addend = Addend;
+        break;
+      }
+      case SymbolRef::ST_Data:
+      case SymbolRef::ST_Unknown: {
+        Value.SymbolName = TargetName.data();
+        Value.Addend = Addend;
+
+        // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
+        // will manifest here as a NULL symbol name.
+        // We can set this as a valid (but empty) symbol name, and rely
+        // on addRelocationForSymbol to handle this.
+        if (!Value.SymbolName)
+          Value.SymbolName = "";
+        break;
+      }
+      default:
+        llvm_unreachable("Unresolved symbol type!");
+        break;
       }
     }
   }
   uint64_t Offset;
   Check(RelI->getOffset(Offset));
 
-  DEBUG(dbgs() << "\t\tSectionID: " << SectionID
-               << " Offset: " << Offset
+  DEBUG(dbgs() << "\t\tSectionID: " << SectionID << " Offset: " << Offset
                << "\n");
   if (Arch == Triple::aarch64 &&
-      (RelType == ELF::R_AARCH64_CALL26 ||
-       RelType == ELF::R_AARCH64_JUMP26)) {
+      (RelType == ELF::R_AARCH64_CALL26 || RelType == ELF::R_AARCH64_JUMP26)) {
     // This is an AArch64 branch relocation, need to use a stub function.
     DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation.");
     SectionEntry &Section = Sections[SectionID];
@@ -1017,24 +956,21 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
     // Look for an existing stub.
     StubMap::const_iterator i = Stubs.find(Value);
     if (i != Stubs.end()) {
-        resolveRelocation(Section, Offset,
-                          (uint64_t)Section.Address + i->second, RelType, 0);
+      resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
+                        RelType, 0);
       DEBUG(dbgs() << " Stub function found\n");
     } else {
       // Create a new stub function.
       DEBUG(dbgs() << " Create a new stub function\n");
       Stubs[Value] = Section.StubOffset;
-      uint8_t *StubTargetAddr = createStubFunction(Section.Address +
-                                                   Section.StubOffset);
+      uint8_t *StubTargetAddr =
+          createStubFunction(Section.Address + Section.StubOffset);
 
-      RelocationEntry REmovz_g3(SectionID,
-                                StubTargetAddr - Section.Address,
+      RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.Address,
                                 ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
-      RelocationEntry REmovk_g2(SectionID,
-                                StubTargetAddr - Section.Address + 4,
+      RelocationEntry REmovk_g2(SectionID, StubTargetAddr - Section.Address + 4,
                                 ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
-      RelocationEntry REmovk_g1(SectionID,
-                                StubTargetAddr - Section.Address + 8,
+      RelocationEntry REmovk_g1(SectionID, StubTargetAddr - Section.Address + 8,
                                 ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
       RelocationEntry REmovk_g0(SectionID,
                                 StubTargetAddr - Section.Address + 12,
@@ -1052,14 +988,13 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
         addRelocationForSection(REmovk_g0, Value.SectionID);
       }
       resolveRelocation(Section, Offset,
-                        (uint64_t)Section.Address + Section.StubOffset,
-                        RelType, 0);
+                        (uint64_t)Section.Address + Section.StubOffset, RelType,
+                        0);
       Section.StubOffset += getMaxStubSize();
     }
   } else if (Arch == Triple::arm &&
-      (RelType == ELF::R_ARM_PC24 ||
-       RelType == ELF::R_ARM_CALL ||
-       RelType == ELF::R_ARM_JUMP24)) {
+             (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL ||
+              RelType == ELF::R_ARM_JUMP24)) {
     // This is an ARM branch relocation, need to use a stub function.
     DEBUG(dbgs() << "\t\tThis is an ARM branch relocation.");
     SectionEntry &Section = Sections[SectionID];
@@ -1067,15 +1002,15 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
     // Look for an existing stub.
     StubMap::const_iterator i = Stubs.find(Value);
     if (i != Stubs.end()) {
-        resolveRelocation(Section, Offset,
-                          (uint64_t)Section.Address + i->second, RelType, 0);
+      resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
+                        RelType, 0);
       DEBUG(dbgs() << " Stub function found\n");
     } else {
       // Create a new stub function.
       DEBUG(dbgs() << " Create a new stub function\n");
       Stubs[Value] = Section.StubOffset;
-      uint8_t *StubTargetAddr = createStubFunction(Section.Address +
-                                                   Section.StubOffset);
+      uint8_t *StubTargetAddr =
+          createStubFunction(Section.Address + Section.StubOffset);
       RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
                          ELF::R_ARM_PRIVATE_0, Value.Addend);
       if (Value.SymbolName)
@@ -1084,8 +1019,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
         addRelocationForSection(RE, Value.SectionID);
 
       resolveRelocation(Section, Offset,
-                        (uint64_t)Section.Address + Section.StubOffset,
-                        RelType, 0);
+                        (uint64_t)Section.Address + Section.StubOffset, RelType,
+                        0);
       Section.StubOffset += getMaxStubSize();
     }
   } else if ((Arch == Triple::mipsel || Arch == Triple::mips) &&
@@ -1111,15 +1046,13 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
       // Create a new stub function.
       DEBUG(dbgs() << " Create a new stub function\n");
       Stubs[Value] = Section.StubOffset;
-      uint8_t *StubTargetAddr = createStubFunction(Section.Address +
-                                                   Section.StubOffset);
+      uint8_t *StubTargetAddr =
+          createStubFunction(Section.Address + Section.StubOffset);
 
       // Creating Hi and Lo relocations for the filled stub instructions.
-      RelocationEntry REHi(SectionID,
-                           StubTargetAddr - Section.Address,
+      RelocationEntry REHi(SectionID, StubTargetAddr - Section.Address,
                            ELF::R_MIPS_UNUSED1, Value.Addend);
-      RelocationEntry RELo(SectionID,
-                           StubTargetAddr - Section.Address + 4,
+      RelocationEntry RELo(SectionID, StubTargetAddr - Section.Address + 4,
                            ELF::R_MIPS_UNUSED2, Value.Addend);
 
       if (Value.SymbolName) {
@@ -1143,7 +1076,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
       uint8_t *Target = Section.Address + Offset;
       bool RangeOverflow = false;
       if (SymType != SymbolRef::ST_Unknown) {
-        // A function call may points to the .opd entry, so the final symbol value
+        // A function call may points to the .opd entry, so the final symbol
+        // value
         // in calculated based in the relocation values in .opd section.
         findOPDEntrySection(Obj, ObjSectionToID, Value);
         uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend;
@@ -1172,36 +1106,32 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
           // Create a new stub function.
           DEBUG(dbgs() << " Create a new stub function\n");
           Stubs[Value] = Section.StubOffset;
-          uint8_t *StubTargetAddr = createStubFunction(Section.Address +
-                                                       Section.StubOffset);
+          uint8_t *StubTargetAddr =
+              createStubFunction(Section.Address + Section.StubOffset);
           RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
                              ELF::R_PPC64_ADDR64, Value.Addend);
 
           // Generates the 64-bits address loads as exemplified in section
           // 4.5.1 in PPC64 ELF ABI.
-          RelocationEntry REhst(SectionID,
-                                StubTargetAddr - Section.Address + 2,
+          RelocationEntry REhst(SectionID, StubTargetAddr - Section.Address + 2,
                                 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
-          RelocationEntry REhr(SectionID,
-                               StubTargetAddr - Section.Address + 6,
+          RelocationEntry REhr(SectionID, StubTargetAddr - Section.Address + 6,
                                ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
-          RelocationEntry REh(SectionID,
-                              StubTargetAddr - Section.Address + 14,
+          RelocationEntry REh(SectionID, StubTargetAddr - Section.Address + 14,
                               ELF::R_PPC64_ADDR16_HI, Value.Addend);
-          RelocationEntry REl(SectionID,
-                              StubTargetAddr - Section.Address + 18,
+          RelocationEntry REl(SectionID, StubTargetAddr - Section.Address + 18,
                               ELF::R_PPC64_ADDR16_LO, Value.Addend);
 
           if (Value.SymbolName) {
             addRelocationForSymbol(REhst, Value.SymbolName);
-            addRelocationForSymbol(REhr,  Value.SymbolName);
-            addRelocationForSymbol(REh,   Value.SymbolName);
-            addRelocationForSymbol(REl,   Value.SymbolName);
+            addRelocationForSymbol(REhr, Value.SymbolName);
+            addRelocationForSymbol(REh, Value.SymbolName);
+            addRelocationForSymbol(REl, Value.SymbolName);
           } else {
             addRelocationForSection(REhst, Value.SectionID);
-            addRelocationForSection(REhr,  Value.SectionID);
-            addRelocationForSection(REh,   Value.SectionID);
-            addRelocationForSection(REl,   Value.SectionID);
+            addRelocationForSection(REhr, Value.SectionID);
+            addRelocationForSection(REh, Value.SectionID);
+            addRelocationForSection(REl, Value.SectionID);
           }
 
           resolveRelocation(Section, Offset,
@@ -1211,7 +1141,7 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
         }
         if (SymType == SymbolRef::ST_Unknown)
           // Restore the TOC for external calls
-          writeInt32BE(Target+4, 0xE8410028); // ld r2,40(r1)
+          writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1)
       }
     } else {
       RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
@@ -1226,8 +1156,7 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
         addRelocationForSection(RE, Value.SectionID);
     }
   } else if (Arch == Triple::systemz &&
-             (RelType == ELF::R_390_PLT32DBL ||
-              RelType == ELF::R_390_GOTENT)) {
+             (RelType == ELF::R_390_PLT32DBL || RelType == ELF::R_390_GOTENT)) {
     // Create function stubs for both PLT and GOT references, regardless of
     // whether the GOT reference is to data or code.  The stub contains the
     // full address of the symbol, as needed by GOT references, and the
@@ -1252,14 +1181,14 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
 
       uintptr_t BaseAddress = uintptr_t(Section.Address);
       uintptr_t StubAlignment = getStubAlignment();
-      StubAddress = (BaseAddress + Section.StubOffset +
-                     StubAlignment - 1) & -StubAlignment;
+      StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
+                    -StubAlignment;
       unsigned StubOffset = StubAddress - BaseAddress;
 
       Stubs[Value] = StubOffset;
       createStubFunction((uint8_t *)StubAddress);
-      RelocationEntry RE(SectionID, StubOffset + 8,
-                         ELF::R_390_64, Value.Addend - Addend);
+      RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64,
+                         Value.Addend - Addend);
       if (Value.SymbolName)
         addRelocationForSymbol(RE, Value.SymbolName);
       else
@@ -1268,15 +1197,17 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
     }
 
     if (RelType == ELF::R_390_GOTENT)
-      resolveRelocation(Section, Offset, StubAddress + 8,
-                        ELF::R_390_PC32DBL, Addend);
+      resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL,
+                        Addend);
     else
       resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
   } else if (Arch == Triple::x86_64 && RelType == ELF::R_X86_64_PLT32) {
-    // The way the PLT relocations normally work is that the linker allocates the
+    // The way the PLT relocations normally work is that the linker allocates
+    // the
     // PLT and this relocation makes a PC-relative call into the PLT.  The PLT
-    // entry will then jump to an address provided by the GOT.  On first call, the
-    // GOT address will point back into PLT code that resolves the symbol.  After
+    // entry will then jump to an address provided by the GOT.  On first call,
+    // the
+    // GOT address will point back into PLT code that resolves the symbol. After
     // the first call, the GOT entry points to the actual function.
     //
     // For local functions we're ignoring all of that here and just replacing
@@ -1302,8 +1233,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
 
         uintptr_t BaseAddress = uintptr_t(Section.Address);
         uintptr_t StubAlignment = getStubAlignment();
-        StubAddress = (BaseAddress + Section.StubOffset +
-                      StubAlignment - 1) & -StubAlignment;
+        StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
+                      -StubAlignment;
         unsigned StubOffset = StubAddress - BaseAddress;
         Stubs[Value] = StubOffset;
         createStubFunction((uint8_t *)StubAddress);
@@ -1312,8 +1243,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
         GOTEntries.push_back(Value);
 
         // Make our stub function a relative call to the GOT entry.
-        RelocationEntry RE(SectionID, StubOffset + 2,
-                           ELF::R_X86_64_GOTPCREL, -4);
+        RelocationEntry RE(SectionID, StubOffset + 2, ELF::R_X86_64_GOTPCREL,
+                           -4);
         addRelocationForSymbol(RE, Value.SymbolName);
 
         // Bump our stub offset counter
@@ -1321,8 +1252,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
       }
 
       // Make the target call a call into the stub table.
-      resolveRelocation(Section, Offset, StubAddress,
-                      ELF::R_X86_64_PC32, Addend);
+      resolveRelocation(Section, Offset, StubAddress, ELF::R_X86_64_PC32,
+                        Addend);
     } else {
       RelocationEntry RE(SectionID, Offset, ELF::R_X86_64_PC32, Value.Addend,
                          Value.Offset);
@@ -1343,8 +1274,8 @@ RuntimeDyldELF::processRelocationRef(unsigned SectionID,
 
 void RuntimeDyldELF::updateGOTEntries(StringRef Name, uint64_t Addr) {
 
-  SmallVectorImpl<std::pair<SID, GOTRelocations> >::iterator it;
-  SmallVectorImpl<std::pair<SID, GOTRelocations> >::iterator end = GOTs.end();
+  SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator it;
+  SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator end = GOTs.end();
 
   for (it = GOTs.begin(); it != end; ++it) {
     GOTRelocations &GOTEntries = it->second;
@@ -1375,18 +1306,19 @@ size_t RuntimeDyldELF::getGOTEntrySize() {
   case Triple::mipsel:
     Result = sizeof(uint32_t);
     break;
-  default: llvm_unreachable("Unsupported CPU type!");
+  default:
+    llvm_unreachable("Unsupported CPU type!");
   }
   return Result;
 }
 
-uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress,
-                                      uint64_t Offset) {
+uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress, uint64_t Offset) {
 
   const size_t GOTEntrySize = getGOTEntrySize();
 
-  SmallVectorImpl<std::pair<SID, GOTRelocations> >::const_iterator it;
-  SmallVectorImpl<std::pair<SID, GOTRelocations> >::const_iterator end = GOTs.end();
+  SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator it;
+  SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator end =
+      GOTs.end();
 
   int GOTIndex = -1;
   for (it = GOTs.begin(); it != end; ++it) {
@@ -1416,11 +1348,11 @@ uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress,
 
     if (GOTIndex != -1) {
       if (GOTEntrySize == sizeof(uint64_t)) {
-        uint64_t *LocalGOTAddr = (uint64_t*)getSectionAddress(GOTSectionID);
+        uint64_t *LocalGOTAddr = (uint64_t *)getSectionAddress(GOTSectionID);
         // Fill in this entry with the address of the symbol being referenced.
         LocalGOTAddr[GOTIndex] = LoadAddress + SymbolOffset;
       } else {
-        uint32_t *LocalGOTAddr = (uint32_t*)getSectionAddress(GOTSectionID);
+        uint32_t *LocalGOTAddr = (uint32_t *)getSectionAddress(GOTSectionID);
         // Fill in this entry with the address of the symbol being referenced.
         LocalGOTAddr[GOTIndex] = (uint32_t)(LoadAddress + SymbolOffset);
       }
@@ -1454,8 +1386,7 @@ void RuntimeDyldELF::finalizeLoad(ObjSectionToIDMap &SectionMap) {
       // needed when GOT-based relocations are applied.
       memset(Addr, 0, TotalSize);
     }
-  }
-  else {
+  } else {
     report_fatal_error("Unable to allocate memory for GOT!");
   }
 
@@ -1475,7 +1406,8 @@ void RuntimeDyldELF::finalizeLoad(ObjSectionToIDMap &SectionMap) {
 bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const {
   if (Buffer->getBufferSize() < strlen(ELF::ElfMagic))
     return false;
-  return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
+  return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic,
+                 strlen(ELF::ElfMagic))) == 0;
 }
 
 bool RuntimeDyldELF::isCompatibleFile(const object::ObjectFile *Obj) const {
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
index 9c81d071d2..27db5cdf42 100644
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
@@ -22,65 +22,41 @@ using namespace llvm;
 namespace llvm {
 
 namespace {
-  // Helper for extensive error checking in debug builds.
-  error_code Check(error_code Err) {
-    if (Err) {
-      report_fatal_error(Err.message());
-    }
-    return Err;
+// Helper for extensive error checking in debug builds.
+error_code Check(error_code Err) {
+  if (Err) {
+    report_fatal_error(Err.message());
   }
+  return Err;
+}
 } // end anonymous namespace
 
 class RuntimeDyldELF : public RuntimeDyldImpl {
-  void resolveRelocation(const SectionEntry &Section,
-                         uint64_t Offset,
-                         uint64_t Value,
-                         uint32_t Type,
-                         int64_t Addend,
-                         uint64_t SymOffset=0);
-
-  void resolveX86_64Relocation(const SectionEntry &Section,
-                               uint64_t Offset,
-                               uint64_t Value,
-                               uint32_t Type,
-                               int64_t  Addend,
+  void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
+                         uint64_t Value, uint32_t Type, int64_t Addend,
+                         uint64_t SymOffset = 0);
+
+  void resolveX86_64Relocation(const SectionEntry &Section, uint64_t Offset,
+                               uint64_t Value, uint32_t Type, int64_t Addend,
                                uint64_t SymOffset);
 
-  void resolveX86Relocation(const SectionEntry &Section,
-                            uint64_t Offset,
-                            uint32_t Value,
-                            uint32_t Type,
-                            int32_t Addend);
-
-  void resolveAArch64Relocation(const SectionEntry &Section,
-                                uint64_t Offset,
-                                uint64_t Value,
-                                uint32_t Type,
-                                int64_t Addend);
-
-  void resolveARMRelocation(const SectionEntry &Section,
-                            uint64_t Offset,
-                            uint32_t Value,
-                            uint32_t Type,
-                            int32_t Addend);
-
-  void resolveMIPSRelocation(const SectionEntry &Section,
-                             uint64_t Offset,
-                             uint32_t Value,
-                             uint32_t Type,
-                             int32_t Addend);
-
-  void resolvePPC64Relocation(const SectionEntry &Section,
-                              uint64_t Offset,
-                              uint64_t Value,
-                              uint32_t Type,
-                              int64_t Addend);
-
-  void resolveSystemZRelocation(const SectionEntry &Section,
-                                uint64_t Offset,
-                                uint64_t Value,
-                                uint32_t Type,
-                                int64_t Addend);
+  void resolveX86Relocation(const SectionEntry &Section, uint64_t Offset,
+                            uint32_t Value, uint32_t Type, int32_t Addend);
+
+  void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
+                                uint64_t Value, uint32_t Type, int64_t Addend);
+
+  void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
+                            uint32_t Value, uint32_t Type, int32_t Addend);
+
+  void resolveMIPSRelocation(const SectionEntry &Section, uint64_t Offset,
+                             uint32_t Value, uint32_t Type, int32_t Addend);
+
+  void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
+                              uint64_t Value, uint32_t Type, int64_t Addend);
+
+  void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
+                                uint64_t Value, uint32_t Type, int64_t Addend);
 
   unsigned getMaxStubSize() override {
     if (Arch == Triple::aarch64)
@@ -107,8 +83,7 @@ class RuntimeDyldELF : public RuntimeDyldImpl {
   }
 
   uint64_t findPPC64TOC() const;
-  void findOPDEntrySection(ObjectImage &Obj,
-                           ObjSectionToIDMap &LocalSections,
+  void findOPDEntrySection(ObjectImage &Obj, ObjSectionToIDMap &LocalSections,
                            RelocationValueRef &Rel);
 
   uint64_t findGOTEntry(uint64_t LoadAddr, uint64_t Offset);
@@ -129,8 +104,7 @@ class RuntimeDyldELF : public RuntimeDyldImpl {
   SmallVector<SID, 2> RegisteredEHFrameSections;
 
 public:
-  RuntimeDyldELF(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm)
-                                          {}
+  RuntimeDyldELF(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
 
   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
   relocation_iterator
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
index 504a3ff670..d89cf533d7 100644
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
@@ -39,7 +39,6 @@ namespace llvm {
 class ObjectBuffer;
 class Twine;
 
-
 /// SectionEntry - represents a section emitted into memory by the dynamic
 /// linker.
 class SectionEntry {
@@ -69,8 +68,9 @@ public:
 
   SectionEntry(StringRef name, uint8_t *address, size_t size,
                uintptr_t objAddress)
-    : Name(name), Address(address), Size(size), LoadAddress((uintptr_t)address),
-      StubOffset(size), ObjAddress(objAddress) {}
+      : Name(name), Address(address), Size(size),
+        LoadAddress((uintptr_t)address), StubOffset(size),
+        ObjAddress(objAddress) {}
 };
 
 /// RelocationEntry - used to represent relocations internally in the dynamic
@@ -101,33 +101,33 @@ public:
   unsigned Size;
 
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
-    : SectionID(id), Offset(offset), RelType(type), Addend(addend),
-      SymOffset(0), IsPCRel(false), Size(0) {}
+      : SectionID(id), Offset(offset), RelType(type), Addend(addend),
+        SymOffset(0), IsPCRel(false), Size(0) {}
 
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
                   uint64_t symoffset)
-    : SectionID(id), Offset(offset), RelType(type), Addend(addend),
-      SymOffset(symoffset), IsPCRel(false), Size(0) {}
+      : SectionID(id), Offset(offset), RelType(type), Addend(addend),
+        SymOffset(symoffset), IsPCRel(false), Size(0) {}
 
   RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
                   bool IsPCRel, unsigned Size)
-    : SectionID(id), Offset(offset), RelType(type), Addend(addend),
-      SymOffset(0), IsPCRel(IsPCRel), Size(Size) {}
+      : SectionID(id), Offset(offset), RelType(type), Addend(addend),
+        SymOffset(0), IsPCRel(IsPCRel), Size(Size) {}
 };
 
 class RelocationValueRef {
 public:
-  unsigned  SectionID;
-  uint64_t  Offset;
-  int64_t   Addend;
+  unsigned SectionID;
+  uint64_t Offset;
+  int64_t Addend;
   const char *SymbolName;
-  RelocationValueRef(): SectionID(0), Offset(0), Addend(0), SymbolName(0) {}
+  RelocationValueRef() : SectionID(0), Offset(0), Addend(0), SymbolName(0) {}
 
   inline bool operator==(const RelocationValueRef &Other) const {
     return SectionID == Other.SectionID && Offset == Other.Offset &&
            Addend == Other.Addend && SymbolName == Other.SymbolName;
   }
-  inline bool operator <(const RelocationValueRef &Other) const {
+  inline bool operator<(const RelocationValueRef &Other) const {
     if (SectionID != Other.SectionID)
       return SectionID < Other.SectionID;
     if (Offset != Other.Offset)
@@ -149,7 +149,7 @@ protected:
   SectionList Sections;
 
   typedef unsigned SID; // Type for SectionIDs
-  #define RTDYLD_INVALID_SECTION_ID ((SID)(-1))
+#define RTDYLD_INVALID_SECTION_ID ((SID)(-1))
 
   // Keep a map of sections from object file to the SectionID which
   // references it.
@@ -221,52 +221,49 @@ protected:
   }
 
   uint8_t *getSectionAddress(unsigned SectionID) {
-    return (uint8_t*)Sections[SectionID].Address;
+    return (uint8_t *)Sections[SectionID].Address;
   }
 
   void writeInt16BE(uint8_t *Addr, uint16_t Value) {
     if (IsTargetLittleEndian)
       Value = sys::SwapByteOrder(Value);
-    *Addr     = (Value >> 8) & 0xFF;
-    *(Addr+1) = Value & 0xFF;
+    *Addr       = (Value >> 8) & 0xFF;
+    *(Addr + 1) = Value & 0xFF;
   }
 
   void writeInt32BE(uint8_t *Addr, uint32_t Value) {
     if (IsTargetLittleEndian)
       Value = sys::SwapByteOrder(Value);
-    *Addr     = (Value >> 24) & 0xFF;
-    *(Addr+1) = (Value >> 16) & 0xFF;
-    *(Addr+2) = (Value >> 8) & 0xFF;
-    *(Addr+3) = Value & 0xFF;
+    *Addr       = (Value >> 24) & 0xFF;
+    *(Addr + 1) = (Value >> 16) & 0xFF;
+    *(Addr + 2) = (Value >> 8) & 0xFF;
+    *(Addr + 3) = Value & 0xFF;
   }
 
   void writeInt64BE(uint8_t *Addr, uint64_t Value) {
     if (IsTargetLittleEndian)
       Value = sys::SwapByteOrder(Value);
-    *Addr     = (Value >> 56) & 0xFF;
-    *(Addr+1) = (Value >> 48) & 0xFF;
-    *(Addr+2) = (Value >> 40) & 0xFF;
-    *(Addr+3) = (Value >> 32) & 0xFF;
-    *(Addr+4) = (Value >> 24) & 0xFF;
-    *(Addr+5) = (Value >> 16) & 0xFF;
-    *(Addr+6) = (Value >> 8) & 0xFF;
-    *(Addr+7) = Value & 0xFF;
+    *Addr       = (Value >> 56) & 0xFF;
+    *(Addr + 1) = (Value >> 48) & 0xFF;
+    *(Addr + 2) = (Value >> 40) & 0xFF;
+    *(Addr + 3) = (Value >> 32) & 0xFF;
+    *(Addr + 4) = (Value >> 24) & 0xFF;
+    *(Addr + 5) = (Value >> 16) & 0xFF;
+    *(Addr + 6) = (Value >> 8) & 0xFF;
+    *(Addr + 7) = Value & 0xFF;
   }
 
   /// \brief Given the common symbols discovered in the object file, emit a
   /// new section for them and update the symbol mappings in the object and
   /// symbol table.
-  void emitCommonSymbols(ObjectImage &Obj,
-                         const CommonSymbolMap &CommonSymbols,
-                         uint64_t TotalSize,
-                         SymbolTableMap &SymbolTable);
+  void emitCommonSymbols(ObjectImage &Obj, const CommonSymbolMap &CommonSymbols,
+                         uint64_t TotalSize, SymbolTableMap &SymbolTable);
 
   /// \brief Emits section data from the object file to the MemoryManager.
   /// \param IsCode if it's true then allocateCodeSection() will be
   ///        used for emits, else allocateDataSection() will be used.
   /// \return SectionID.
-  unsigned emitSection(ObjectImage &Obj,
-                       const SectionRef &Section,
+  unsigned emitSection(ObjectImage &Obj, const SectionRef &Section,
                        bool IsCode);
 
   /// \brief Find Section in LocalSections. If the secton is not found - emit
@@ -274,10 +271,8 @@ protected:
   /// \param IsCode if it's true then allocateCodeSection() will be
   ///        used for emmits, else allocateDataSection() will be used.
   /// \return SectionID.
-  unsigned findOrEmitSection(ObjectImage &Obj,
-                             const SectionRef &Section,
-                             bool IsCode,
-                             ObjSectionToIDMap &LocalSections);
+  unsigned findOrEmitSection(ObjectImage &Obj, const SectionRef &Section,
+                             bool IsCode, ObjSectionToIDMap &LocalSections);
 
   // \brief Add a relocation entry that uses the given section.
   void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
@@ -288,7 +283,7 @@ protected:
 
   /// \brief Emits long jump instruction to Addr.
   /// \return Pointer to the memory area for emitting target address.
-  uint8_t* createStubFunction(uint8_t *Addr);
+  uint8_t *createStubFunction(uint8_t *Addr);
 
   /// \brief Resolves relocations from Relocs list with address from Value.
   void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
@@ -312,19 +307,18 @@ protected:
   // The base class does nothing.  ELF overrides this.
   virtual void updateGOTEntries(StringRef Name, uint64_t Addr) {}
 
-  // \brief Compute an upper bound of the memory that is required to load all sections
-  void computeTotalAllocSize(ObjectImage &Obj, 
-                             uint64_t& CodeSize, 
-                             uint64_t& DataSizeRO, 
-                             uint64_t& DataSizeRW); 
-  
+  // \brief Compute an upper bound of the memory that is required to load all
+  // sections
+  void computeTotalAllocSize(ObjectImage &Obj, uint64_t &CodeSize,
+                             uint64_t &DataSizeRO, uint64_t &DataSizeRW);
+
   // \brief Compute the stub buffer size required for a section
   unsigned computeSectionStubBufSize(ObjectImage &Obj,
                                      const SectionRef &Section);
 
 public:
   RuntimeDyldImpl(RTDyldMemoryManager *mm)
-    : MemMgr(mm), ProcessAllSections(false), HasError(false) {}
+      : MemMgr(mm), ProcessAllSections(false), HasError(false) {}
 
   virtual ~RuntimeDyldImpl();
 
@@ -332,7 +326,7 @@ public:
     this->ProcessAllSections = ProcessAllSections;
   }
 
-  ObjectImage* loadObject(ObjectImage* InputObject);
+  ObjectImage *loadObject(ObjectImage *InputObject);
 
   void *getSymbolAddress(StringRef Name) {
     // FIXME: Just look up as a function for now. Overly simple of course.
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
index 0f9fc9169d..c1fd821123 100644
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
@@ -20,18 +20,19 @@ using namespace llvm::object;
 
 namespace llvm {
 
-static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText, intptr_t DeltaForEH) {
-  uint32_t Length = *((uint32_t*)P);
+static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText,
+                                 intptr_t DeltaForEH) {
+  uint32_t Length = *((uint32_t *)P);
   P += 4;
   unsigned char *Ret = P + Length;
-  uint32_t Offset = *((uint32_t*)P);
+  uint32_t Offset = *((uint32_t *)P);
   if (Offset == 0) // is a CIE
     return Ret;
 
   P += 4;
-  intptr_t FDELocation = *((intptr_t*)P);
+  intptr_t FDELocation = *((intptr_t *)P);
   intptr_t NewLocation = FDELocation - DeltaForText;
-  *((intptr_t*)P) = NewLocation;
+  *((intptr_t *)P) = NewLocation;
   P += sizeof(intptr_t);
 
   // Skip the FDE address range
@@ -40,16 +41,16 @@ static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText, intptr
   uint8_t Augmentationsize = *P;
   P += 1;
   if (Augmentationsize != 0) {
-    intptr_t LSDA = *((intptr_t*)P);
+    intptr_t LSDA = *((intptr_t *)P);
     intptr_t NewLSDA = LSDA - DeltaForEH;
-    *((intptr_t*)P) = NewLSDA;
+    *((intptr_t *)P) = NewLSDA;
   }
 
   return Ret;
 }
 
 static intptr_t computeDelta(SectionEntry *A, SectionEntry *B) {
-  intptr_t ObjDistance = A->ObjAddress  - B->ObjAddress;
+  intptr_t ObjDistance = A->ObjAddress - B->ObjAddress;
   intptr_t MemDistance = A->LoadAddress - B->LoadAddress;
   return ObjDistance - MemDistance;
 }
@@ -76,12 +77,11 @@ void RuntimeDyldMachO::registerEHFrames() {
 
     unsigned char *P = EHFrame->Address;
     unsigned char *End = P + EHFrame->Size;
-    do  {
+    do {
       P = processFDE(P, DeltaForText, DeltaForEH);
-    } while(P != End);
+    } while (P != End);
 
-    MemMgr->registerEHFrames(EHFrame->Address,
-                             EHFrame->LoadAddress,
+    MemMgr->registerEHFrames(EHFrame->Address, EHFrame->LoadAddress,
                              EHFrame->Size);
   }
   UnregisteredEHFrameSections.clear();
@@ -103,9 +103,8 @@ void RuntimeDyldMachO::finalizeLoad(ObjSectionToIDMap &SectionMap) {
     else if (Name == "__gcc_except_tab")
       ExceptTabSID = i->second;
   }
-  UnregisteredEHFrameSections.push_back(EHFrameRelatedSections(EHFrameSID,
-                                                               TextSID,
-                                                               ExceptTabSID));
+  UnregisteredEHFrameSections.push_back(
+      EHFrameRelatedSections(EHFrameSID, TextSID, ExceptTabSID));
 }
 
 // The target location for the relocation is described by RE.SectionID and
@@ -136,67 +135,45 @@ void RuntimeDyldMachO::resolveRelocation(const RelocationEntry &RE,
 }
 
 void RuntimeDyldMachO::resolveRelocation(const SectionEntry &Section,
-                                         uint64_t Offset,
-                                         uint64_t Value,
-                                         uint32_t Type,
-                                         int64_t Addend,
-                                         bool isPCRel,
-                                         unsigned LogSize) {
+                                         uint64_t Offset, uint64_t Value,
+                                         uint32_t Type, int64_t Addend,
+                                         bool isPCRel, unsigned LogSize) {
   uint8_t *LocalAddress = Section.Address + Offset;
   uint64_t FinalAddress = Section.LoadAddress + Offset;
   unsigned MachoType = Type;
   unsigned Size = 1 << LogSize;
 
   DEBUG(dbgs() << "resolveRelocation LocalAddress: "
-        << format("%p", LocalAddress)
-        << " FinalAddress: " << format("%p", FinalAddress)
-        << " Value: " << format("%p", Value)
-        << " Addend: " << Addend
-        << " isPCRel: " << isPCRel
-        << " MachoType: " << MachoType
-        << " Size: " << Size
-        << "\n");
+               << format("%p", LocalAddress)
+               << " FinalAddress: " << format("%p", FinalAddress)
+               << " Value: " << format("%p", Value) << " Addend: " << Addend
+               << " isPCRel: " << isPCRel << " MachoType: " << MachoType
+               << " Size: " << Size << "\n");
 
   // This just dispatches to the proper target specific routine.
   switch (Arch) {
-  default: llvm_unreachable("Unsupported CPU type!");
+  default:
+    llvm_unreachable("Unsupported CPU type!");
   case Triple::x86_64:
-    resolveX86_64Relocation(LocalAddress,
-                            FinalAddress,
-                            (uintptr_t)Value,
-                            isPCRel,
-                            MachoType,
-                            Size,
-                            Addend);
+    resolveX86_64Relocation(LocalAddress, FinalAddress, (uintptr_t)Value,
+                            isPCRel, MachoType, Size, Addend);
     break;
   case Triple::x86:
-    resolveI386Relocation(LocalAddress,
-                          FinalAddress,
-                          (uintptr_t)Value,
-                          isPCRel,
-                          MachoType,
-                          Size,
-                          Addend);
+    resolveI386Relocation(LocalAddress, FinalAddress, (uintptr_t)Value, isPCRel,
+                          MachoType, Size, Addend);
     break;
-  case Triple::arm:    // Fall through.
+  case Triple::arm: // Fall through.
   case Triple::thumb:
-    resolveARMRelocation(LocalAddress,
-                         FinalAddress,
-                         (uintptr_t)Value,
-                         isPCRel,
-                         MachoType,
-                         Size,
-                         Addend);
+    resolveARMRelocation(LocalAddress, FinalAddress, (uintptr_t)Value, isPCRel,
+                         MachoType, Size, Addend);
     break;
   }
 }
 
 bool RuntimeDyldMachO::resolveI386Relocation(uint8_t *LocalAddress,
                                              uint64_t FinalAddress,
-                                             uint64_t Value,
-                                             bool isPCRel,
-                                             unsigned Type,
-                                             unsigned Size,
+                                             uint64_t Value, bool isPCRel,
+                                             unsigned Type, unsigned Size,
                                              int64_t Addend) {
   if (isPCRel)
     Value -= FinalAddress + 4; // see resolveX86_64Relocation
@@ -222,10 +199,8 @@ bool RuntimeDyldMachO::resolveI386Relocation(uint8_t *LocalAddress,
 
 bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
                                                uint64_t FinalAddress,
-                                               uint64_t Value,
-                                               bool isPCRel,
-                                               unsigned Type,
-                                               unsigned Size,
+                                               uint64_t Value, bool isPCRel,
+                                               unsigned Type, unsigned Size,
                                                int64_t Addend) {
   // If the relocation is PC-relative, the value to be encoded is the
   // pointer difference.
@@ -234,7 +209,7 @@ bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
     // address. Is that expected? Only for branches, perhaps?
     Value -= FinalAddress + 4;
 
-  switch(Type) {
+  switch (Type) {
   default:
     llvm_unreachable("Invalid relocation type!");
   case MachO::X86_64_RELOC_SIGNED_1:
@@ -246,7 +221,7 @@ bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
     Value += Addend;
     // Mask in the target value a byte at a time (we don't have an alignment
     // guarantee for the target address, so this is safest).
-    uint8_t *p = (uint8_t*)LocalAddress;
+    uint8_t *p = (uint8_t *)LocalAddress;
     for (unsigned i = 0; i < Size; ++i) {
       *p++ = (uint8_t)Value;
       Value >>= 8;
@@ -263,10 +238,8 @@ bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
 
 bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
                                             uint64_t FinalAddress,
-                                            uint64_t Value,
-                                            bool isPCRel,
-                                            unsigned Type,
-                                            unsigned Size,
+                                            uint64_t Value, bool isPCRel,
+                                            unsigned Type, unsigned Size,
                                             int64_t Addend) {
   // If the relocation is PC-relative, the value to be encoded is the
   // pointer difference.
@@ -278,13 +251,13 @@ bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
     Value -= 8;
   }
 
-  switch(Type) {
+  switch (Type) {
   default:
     llvm_unreachable("Invalid relocation type!");
   case MachO::ARM_RELOC_VANILLA: {
     // Mask in the target value a byte at a time (we don't have an alignment
     // guarantee for the target address, so this is safest).
-    uint8_t *p = (uint8_t*)LocalAddress;
+    uint8_t *p = (uint8_t *)LocalAddress;
     for (unsigned i = 0; i < Size; ++i) {
       *p++ = (uint8_t)Value;
       Value >>= 8;
@@ -294,7 +267,7 @@ bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
   case MachO::ARM_RELOC_BR24: {
     // Mask the value into the target address. We know instructions are
     // 32-bit aligned, so we can do it all at once.
-    uint32_t *p = (uint32_t*)LocalAddress;
+    uint32_t *p = (uint32_t *)LocalAddress;
     // The low two bits of the value are not encoded.
     Value >>= 2;
     // Mask the value to 24 bits.
@@ -320,17 +293,14 @@ bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
   return false;
 }
 
-relocation_iterator
-RuntimeDyldMachO::processRelocationRef(unsigned SectionID,
-                                       relocation_iterator RelI,
-                                       ObjectImage &Obj,
-                                       ObjSectionToIDMap &ObjSectionToID,
-                                       const SymbolTableMap &Symbols,
-                                       StubMap &Stubs) {
+relocation_iterator RuntimeDyldMachO::processRelocationRef(
+    unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
+    ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols,
+    StubMap &Stubs) {
   const ObjectFile *OF = Obj.getObjectFile();
-  const MachOObjectFile *MachO = static_cast<const MachOObjectFile*>(OF);
+  const MachOObjectFile *MachO = static_cast<const MachOObjectFile *>(OF);
   MachO::any_relocation_info RE =
-    MachO->getRelocation(RelI->getRawDataRefImpl());
+      MachO->getRelocation(RelI->getRawDataRefImpl());
 
   uint32_t RelType = MachO->getAnyRelocationType(RE);
 
@@ -368,7 +338,8 @@ RuntimeDyldMachO::processRelocationRef(unsigned SectionID,
       Value.Addend = lsi->second.second + Addend;
     } else {
       // Search for the symbol in the global symbol table
-      SymbolTableMap::const_iterator gsi = GlobalSymbolTable.find(TargetName.data());
+      SymbolTableMap::const_iterator gsi =
+          GlobalSymbolTable.find(TargetName.data());
       if (gsi != GlobalSymbolTable.end()) {
         Value.SectionID = gsi->second.first;
         Value.Addend = gsi->second.second + Addend;
@@ -411,21 +382,19 @@ RuntimeDyldMachO::processRelocationRef(unsigned SectionID,
     }
     resolveRelocation(Section, Offset, (uint64_t)Addr,
                       MachO::X86_64_RELOC_UNSIGNED, Value.Addend, true, 2);
-  } else if (Arch == Triple::arm &&
-             (RelType & 0xf) == MachO::ARM_RELOC_BR24) {
+  } else if (Arch == Triple::arm && (RelType & 0xf) == MachO::ARM_RELOC_BR24) {
     // This is an ARM branch relocation, need to use a stub function.
 
     //  Look up for existing stub.
     StubMap::const_iterator i = Stubs.find(Value);
     if (i != Stubs.end())
-      resolveRelocation(Section, Offset,
-                        (uint64_t)Section.Address + i->second,
+      resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
                         RelType, 0, IsPCRel, Size);
     else {
       // Create a new stub function.
       Stubs[Value] = Section.StubOffset;
-      uint8_t *StubTargetAddr = createStubFunction(Section.Address +
-                                                   Section.StubOffset);
+      uint8_t *StubTargetAddr =
+          createStubFunction(Section.Address + Section.StubOffset);
       RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
                          MachO::GENERIC_RELOC_VANILLA, Value.Addend);
       if (Value.SymbolName)
@@ -433,13 +402,12 @@ RuntimeDyldMachO::processRelocationRef(unsigned SectionID,
       else
         addRelocationForSection(RE, Value.SectionID);
       resolveRelocation(Section, Offset,
-                        (uint64_t)Section.Address + Section.StubOffset,
-                        RelType, 0, IsPCRel, Size);
+                        (uint64_t)Section.Address + Section.StubOffset, RelType,
+                        0, IsPCRel, Size);
       Section.StubOffset += getMaxStubSize();
     }
   } else {
-    RelocationEntry RE(SectionID, Offset, RelType, Value.Addend,
-                       IsPCRel, Size);
+    RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, IsPCRel, Size);
     if (Value.SymbolName)
       addRelocationForSymbol(RE, Value.SymbolName);
     else
@@ -448,21 +416,23 @@ RuntimeDyldMachO::processRelocationRef(unsigned SectionID,
   return ++RelI;
 }
 
-
-bool RuntimeDyldMachO::isCompatibleFormat(
-        const ObjectBuffer *InputBuffer) const {
+bool
+RuntimeDyldMachO::isCompatibleFormat(const ObjectBuffer *InputBuffer) const {
   if (InputBuffer->getBufferSize() < 4)
     return false;
   StringRef Magic(InputBuffer->getBufferStart(), 4);
-  if (Magic == "\xFE\xED\xFA\xCE") return true;
-  if (Magic == "\xCE\xFA\xED\xFE") return true;
-  if (Magic == "\xFE\xED\xFA\xCF") return true;
-  if (Magic == "\xCF\xFA\xED\xFE") return true;
+  if (Magic == "\xFE\xED\xFA\xCE")
+    return true;
+  if (Magic == "\xCE\xFA\xED\xFE")
+    return true;
+  if (Magic == "\xFE\xED\xFA\xCF")
+    return true;
+  if (Magic == "\xCF\xFA\xED\xFE")
+    return true;
   return false;
 }
 
-bool RuntimeDyldMachO::isCompatibleFile(
-        const object::ObjectFile *Obj) const {
+bool RuntimeDyldMachO::isCompatibleFile(const object::ObjectFile *Obj) const {
   return Obj->isMachO();
 }
 
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
index 48b0481ce5..edcd8895e1 100644
--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
+++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
@@ -23,38 +23,21 @@
 using namespace llvm;
 using namespace llvm::object;
 
-
 namespace llvm {
 class RuntimeDyldMachO : public RuntimeDyldImpl {
-  bool resolveI386Relocation(uint8_t *LocalAddress,
-                             uint64_t FinalAddress,
-                             uint64_t Value,
-                             bool isPCRel,
-                             unsigned Type,
-                             unsigned Size,
-                             int64_t Addend);
-  bool resolveX86_64Relocation(uint8_t *LocalAddress,
-                               uint64_t FinalAddress,
-                               uint64_t Value,
-                               bool isPCRel,
-                               unsigned Type,
-                               unsigned Size,
-                               int64_t Addend);
-  bool resolveARMRelocation(uint8_t *LocalAddress,
-                            uint64_t FinalAddress,
-                            uint64_t Value,
-                            bool isPCRel,
-                            unsigned Type,
-                            unsigned Size,
-                            int64_t Addend);
-
-  void resolveRelocation(const SectionEntry &Section,
-                         uint64_t Offset,
-                         uint64_t Value,
-                         uint32_t Type,
-                         int64_t Addend,
-                         bool isPCRel,
-                         unsigned Size);
+  bool resolveI386Relocation(uint8_t *LocalAddress, uint64_t FinalAddress,
+                             uint64_t Value, bool isPCRel, unsigned Type,
+                             unsigned Size, int64_t Addend);
+  bool resolveX86_64Relocation(uint8_t *LocalAddress, uint64_t FinalAddress,
+                               uint64_t Value, bool isPCRel, unsigned Type,
+                               unsigned Size, int64_t Addend);
+  bool resolveARMRelocation(uint8_t *LocalAddress, uint64_t FinalAddress,
+                            uint64_t Value, bool isPCRel, unsigned Type,
+                            unsigned Size, int64_t Addend);
+
+  void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
+                         uint64_t Value, uint32_t Type, int64_t Addend,
+                         bool isPCRel, unsigned Size);
 
   unsigned getMaxStubSize() override {
     if (Arch == Triple::arm || Arch == Triple::thumb)
@@ -65,16 +48,15 @@ class RuntimeDyldMachO : public RuntimeDyldImpl {
       return 0;
   }
 
-  unsigned getStubAlignment() override {
-    return 1;
-  }
+  unsigned getStubAlignment() override { return 1; }
 
   struct EHFrameRelatedSections {
-    EHFrameRelatedSections() : EHFrameSID(RTDYLD_INVALID_SECTION_ID),
-                               TextSID(RTDYLD_INVALID_SECTION_ID),
-                               ExceptTabSID(RTDYLD_INVALID_SECTION_ID) {}
+    EHFrameRelatedSections()
+        : EHFrameSID(RTDYLD_INVALID_SECTION_ID),
+          TextSID(RTDYLD_INVALID_SECTION_ID),
+          ExceptTabSID(RTDYLD_INVALID_SECTION_ID) {}
     EHFrameRelatedSections(SID EH, SID T, SID Ex)
-      : EHFrameSID(EH), TextSID(T), ExceptTabSID(Ex) {}
+        : EHFrameSID(EH), TextSID(T), ExceptTabSID(Ex) {}
     SID EHFrameSID;
     SID TextSID;
     SID ExceptTabSID;
@@ -84,6 +66,7 @@ class RuntimeDyldMachO : public RuntimeDyldImpl {
   // in a table until we receive a request to register all unregistered
   // EH frame sections with the memory manager.
   SmallVector<EHFrameRelatedSections, 2> UnregisteredEHFrameSections;
+
 public:
   RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
 
@@ -97,12 +80,12 @@ public:
   void registerEHFrames() override;
   void finalizeLoad(ObjSectionToIDMap &SectionMap) override;
 
-
   static ObjectImage *createObjectImage(ObjectBuffer *InputBuffer) {
     return new ObjectImageCommon(InputBuffer);
   }
 
-  static ObjectImage *createObjectImageFromFile(object::ObjectFile *InputObject) {
+  static ObjectImage *
+  createObjectImageFromFile(object::ObjectFile *InputObject) {
     return new ObjectImageCommon(InputObject);
   }
 };