Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release:

MFC r309142 (by emaste):

Add WITH_LLD_AS_LD build knob

If set it installs LLD as /usr/bin/ld.  LLD (as of version 3.9) is not
capable of linking the world and kernel, but can self-host and link many
substantial applications. GNU ld continues to be used for the world and
kernel build, regardless of how this knob is set.

It is on by default for arm64, and off for all other CPU architectures.

Sponsored by:	The FreeBSD Foundation

MFC r310840:

Reapply 310775, now it also builds correctly if lldb is disabled:

Move llvm-objdump from CLANG_EXTRAS to installed by default

We currently install three tools from binutils 2.17.50: as, ld, and
objdump. Work is underway to migrate to a permissively-licensed
tool-chain, with one goal being the retirement of binutils 2.17.50.

LLVM's llvm-objdump is intended to be compatible with GNU objdump
although it is currently missing some options and may have formatting
differences. Enable it by default for testing and further investigation.
It may later be changed to install as /usr/bin/objdump, it becomes a
fully viable replacement.

Reviewed by:	emaste
Differential Revision:	https://reviews.freebsd.org/D8879

MFC r312855 (by emaste):

Rename LLD_AS_LD to LLD_IS_LD, for consistency with CLANG_IS_CC

Reported by:	Dan McGregor <dan.mcgregor usask.ca>

MFC r313559 | glebius | 2017-02-10 18:34:48 +0100 (Fri, 10 Feb 2017) | 5 lines

Don't check struct rtentry on FreeBSD, it is an internal kernel structure.
On other systems it may be API structure for SIOCADDRT/SIOCDELRT.

Reviewed by:	emaste, dim

MFC r314152 (by jkim):

Remove an assembler flag, which is redundant since r309124.  The upstream
took care of it by introducing a macro NO_EXEC_STACK_DIRECTIVE.

http://llvm.org/viewvc/llvm-project?rev=273500&view=rev

Reviewed by:	dim

MFC r314564:

Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
4.0.0 (branches/release_40 296509).  The release will follow soon.

Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11
support to build; see UPDATING for more information.

Also note that as of 4.0.0, lld should be able to link the base system
on amd64 and aarch64.  See the WITH_LLD_IS_LLD setting in src.conf(5).
Though please be aware that this is work in progress.

Release notes for llvm, clang and lld will be available here:
<http://releases.llvm.org/4.0.0/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/clang/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/lld/docs/ReleaseNotes.html>

Thanks to Ed Maste, Jan Beich, Antoine Brodin and Eric Fiselier for
their help.

Relnotes:	yes
Exp-run:	antoine
PR:		215969, 216008

MFC r314708:

For now, revert r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

This commit is the cause of excessive compile times on skein_block.c
(and possibly other files) during kernel builds on amd64.

We never saw the problematic behavior described in this upstream commit,
so for now it is better to revert it.  An upstream bug has been filed
here: https://bugs.llvm.org/show_bug.cgi?id=32142

Reported by:	mjg

MFC r314795:

Reapply r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

Pull in r296992 from upstream llvm trunk (by Sanjoy Das):

  [SCEV] Decrease the recursion threshold for CompareValueComplexity

  Fixes PR32142.

  r287232 accidentally increased the recursion threshold for
  CompareValueComplexity from 2 to 32.  This change reverses that
  change by introducing a separate flag for CompareValueComplexity's
  threshold.

The latter revision fixes the excessive compile times for skein_block.c.

MFC r314907 | mmel | 2017-03-08 12:40:27 +0100 (Wed, 08 Mar 2017) | 7 lines

Unbreak ARMv6 world.

The new compiler_rt library imported with clang 4.0.0 have several fatal
issues (non-functional __udivsi3 for example) with ARM specific instrict
functions. As temporary workaround, until upstream solve these problems,
disable all thumb[1][2] related feature.

MFC r315016:

Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release.
We were already very close to the last release candidate, so this is a
pretty minor update.

Relnotes:	yes

MFC r316005:

Revert r314907, and pull in r298713 from upstream compiler-rt trunk (by
Weiming Zhao):

  builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA.

  Summary:
  Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation
  mode (-mthumb, -marm), it reflect's capability of given CPU.

  Due to this:
   - use  __tbumb__ and __thumb2__ insteand of __ARM_ARCH_ISA_THUMB
   - use '.thumb' directive consistently  in all affected files
   - decorate all thumb functions using
     DEFINE_COMPILERRT_THUMB_FUNCTION()

  ---------
  Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 !

  Reviewers: weimingz, rengolin, compnerd

  Subscribers: aemerson, dim

  Differential Revision: https://reviews.llvm.org/D30938

Discussed with:	mmel

14 files changed, 2687 insertions, 3046 deletions

diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp
index 1f77539..3c64b2f 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp
@@ -1,4 +1,4 @@
-//===-- DynamicLoaderHexagon.h ----------------------------------*- C++ -*-===//
+//===-- DynamicLoaderHexagonDYLD.cpp ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -10,17 +10,17 @@
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Core/PluginManager.h"
+#include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
-#include "lldb/Breakpoint/BreakpointLocation.h"
 
 #include "DynamicLoaderHexagonDYLD.h"
 
@@ -31,562 +31,490 @@ using namespace lldb_private;
 //
 // Notes about hexagon dynamic loading:
 //
-//      When we connect to a target we find the dyld breakpoint address.  We put a
+//      When we connect to a target we find the dyld breakpoint address.  We put
+//      a
 //      breakpoint there with a callback 'RendezvousBreakpointHit()'.
 //
-//      It is possible to find the dyld structure address from the ELF symbol table,
-//      but in the case of the simulator it has not been initialized before the 
+//      It is possible to find the dyld structure address from the ELF symbol
+//      table,
+//      but in the case of the simulator it has not been initialized before the
 //      target calls dlinit().
 //
-//      We can only safely parse the dyld structure after we hit the dyld breakpoint
+//      We can only safely parse the dyld structure after we hit the dyld
+//      breakpoint
 //      since at that time we know dlinit() must have been called.
 //
 
 // Find the load address of a symbol
-static lldb::addr_t findSymbolAddress( Process *proc, ConstString findName )
-{
-    assert( proc != nullptr );
-
-    ModuleSP module = proc->GetTarget().GetExecutableModule();
-    assert( module.get() != nullptr );
-
-    ObjectFile *exe = module->GetObjectFile();
-    assert( exe != nullptr );
-
-    lldb_private::Symtab *symtab = exe->GetSymtab( );
-    assert( symtab != nullptr );
-
-    for ( size_t i = 0; i < symtab->GetNumSymbols( ); i++ )
-    {
-        const Symbol* sym = symtab->SymbolAtIndex( i );
-        assert( sym != nullptr );
-        const ConstString &symName = sym->GetName( );
-
-        if ( ConstString::Compare( findName, symName ) == 0 )
-        {
-            Address addr = sym->GetAddress();
-            return addr.GetLoadAddress( & proc->GetTarget() );
-        }
-    }
-    return LLDB_INVALID_ADDRESS;
-}
+static lldb::addr_t findSymbolAddress(Process *proc, ConstString findName) {
+  assert(proc != nullptr);
 
-void
-DynamicLoaderHexagonDYLD::Initialize()
-{
-    PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                  GetPluginDescriptionStatic(),
-                                  CreateInstance);
-}
+  ModuleSP module = proc->GetTarget().GetExecutableModule();
+  assert(module.get() != nullptr);
+
+  ObjectFile *exe = module->GetObjectFile();
+  assert(exe != nullptr);
+
+  lldb_private::Symtab *symtab = exe->GetSymtab();
+  assert(symtab != nullptr);
+
+  for (size_t i = 0; i < symtab->GetNumSymbols(); i++) {
+    const Symbol *sym = symtab->SymbolAtIndex(i);
+    assert(sym != nullptr);
+    const ConstString &symName = sym->GetName();
 
-void
-DynamicLoaderHexagonDYLD::Terminate()
-{
+    if (ConstString::Compare(findName, symName) == 0) {
+      Address addr = sym->GetAddress();
+      return addr.GetLoadAddress(&proc->GetTarget());
+    }
+  }
+  return LLDB_INVALID_ADDRESS;
 }
 
-lldb_private::ConstString
-DynamicLoaderHexagonDYLD::GetPluginName()
-{
-    return GetPluginNameStatic();
+void DynamicLoaderHexagonDYLD::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance);
 }
 
-lldb_private::ConstString
-DynamicLoaderHexagonDYLD::GetPluginNameStatic()
-{
-    static ConstString g_name("hexagon-dyld");
-    return g_name;
+void DynamicLoaderHexagonDYLD::Terminate() {}
+
+lldb_private::ConstString DynamicLoaderHexagonDYLD::GetPluginName() {
+  return GetPluginNameStatic();
 }
 
-const char *
-DynamicLoaderHexagonDYLD::GetPluginDescriptionStatic()
-{
-    return "Dynamic loader plug-in that watches for shared library "
-           "loads/unloads in Hexagon processes.";
+lldb_private::ConstString DynamicLoaderHexagonDYLD::GetPluginNameStatic() {
+  static ConstString g_name("hexagon-dyld");
+  return g_name;
 }
 
-uint32_t
-DynamicLoaderHexagonDYLD::GetPluginVersion()
-{
-    return 1;
+const char *DynamicLoaderHexagonDYLD::GetPluginDescriptionStatic() {
+  return "Dynamic loader plug-in that watches for shared library "
+         "loads/unloads in Hexagon processes.";
 }
 
-DynamicLoader *
-DynamicLoaderHexagonDYLD::CreateInstance(Process *process, bool force)
-{
-    bool create = force;
-    if (!create)
-    {
-        const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
-        if (triple_ref.getArch() == llvm::Triple::hexagon)
-            create = true;
-    }
-    
-    if (create)
-        return new DynamicLoaderHexagonDYLD(process);
-    return NULL;
+uint32_t DynamicLoaderHexagonDYLD::GetPluginVersion() { return 1; }
+
+DynamicLoader *DynamicLoaderHexagonDYLD::CreateInstance(Process *process,
+                                                        bool force) {
+  bool create = force;
+  if (!create) {
+    const llvm::Triple &triple_ref =
+        process->GetTarget().GetArchitecture().GetTriple();
+    if (triple_ref.getArch() == llvm::Triple::hexagon)
+      create = true;
+  }
+
+  if (create)
+    return new DynamicLoaderHexagonDYLD(process);
+  return NULL;
 }
 
 DynamicLoaderHexagonDYLD::DynamicLoaderHexagonDYLD(Process *process)
-    : DynamicLoader(process)
-    , m_rendezvous (process)
-    , m_load_offset(LLDB_INVALID_ADDRESS)
-    , m_entry_point(LLDB_INVALID_ADDRESS)
-    , m_dyld_bid   (LLDB_INVALID_BREAK_ID)
-{
+    : DynamicLoader(process), m_rendezvous(process),
+      m_load_offset(LLDB_INVALID_ADDRESS), m_entry_point(LLDB_INVALID_ADDRESS),
+      m_dyld_bid(LLDB_INVALID_BREAK_ID) {}
+
+DynamicLoaderHexagonDYLD::~DynamicLoaderHexagonDYLD() {
+  if (m_dyld_bid != LLDB_INVALID_BREAK_ID) {
+    m_process->GetTarget().RemoveBreakpointByID(m_dyld_bid);
+    m_dyld_bid = LLDB_INVALID_BREAK_ID;
+  }
 }
 
-DynamicLoaderHexagonDYLD::~DynamicLoaderHexagonDYLD()
-{
-    if (m_dyld_bid != LLDB_INVALID_BREAK_ID)
-    {
-        m_process->GetTarget().RemoveBreakpointByID (m_dyld_bid);
-        m_dyld_bid = LLDB_INVALID_BREAK_ID;
-    }
-}
+void DynamicLoaderHexagonDYLD::DidAttach() {
+  ModuleSP executable;
+  addr_t load_offset;
 
-void
-DynamicLoaderHexagonDYLD::DidAttach()
-{
-    ModuleSP executable;
-    addr_t load_offset;
-
-    executable = GetTargetExecutable();
-
-    // Find the difference between the desired load address in the elf file
-    // and the real load address in memory
-    load_offset = ComputeLoadOffset();
-
-    // Check that there is a valid executable
-    if ( executable.get( ) == nullptr )
-        return;
-        
-    // Disable JIT for hexagon targets because its not supported
-    m_process->SetCanJIT(false);
-
-    // Enable Interpreting of function call expressions
-    m_process->SetCanInterpretFunctionCalls(true);
-
-    // Add the current executable to the module list
-    ModuleList module_list;
-    module_list.Append(executable);
-
-    // Map the loaded sections of this executable
-    if ( load_offset != LLDB_INVALID_ADDRESS )
-        UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
-
-    // AD: confirm this?
-    // Load into LLDB all of the currently loaded executables in the stub
-    LoadAllCurrentModules();
-
-    // AD: confirm this?
-    // Callback for the target to give it the loaded module list
-    m_process->GetTarget().ModulesDidLoad(module_list);
-
-    // Try to set a breakpoint at the rendezvous breakpoint.
-    // DidLaunch uses ProbeEntry() instead.  That sets a breakpoint,
-    // at the dyld breakpoint address, with a callback so that when hit,
-    // the dyld structure can be parsed.
-    if (! SetRendezvousBreakpoint() )
-    {
-        // fail
-    }
-}
+  executable = GetTargetExecutable();
+
+  // Find the difference between the desired load address in the elf file
+  // and the real load address in memory
+  load_offset = ComputeLoadOffset();
+
+  // Check that there is a valid executable
+  if (executable.get() == nullptr)
+    return;
+
+  // Disable JIT for hexagon targets because its not supported
+  m_process->SetCanJIT(false);
+
+  // Enable Interpreting of function call expressions
+  m_process->SetCanInterpretFunctionCalls(true);
 
-void
-DynamicLoaderHexagonDYLD::DidLaunch()
-{
+  // Add the current executable to the module list
+  ModuleList module_list;
+  module_list.Append(executable);
+
+  // Map the loaded sections of this executable
+  if (load_offset != LLDB_INVALID_ADDRESS)
+    UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
+
+  // AD: confirm this?
+  // Load into LLDB all of the currently loaded executables in the stub
+  LoadAllCurrentModules();
+
+  // AD: confirm this?
+  // Callback for the target to give it the loaded module list
+  m_process->GetTarget().ModulesDidLoad(module_list);
+
+  // Try to set a breakpoint at the rendezvous breakpoint.
+  // DidLaunch uses ProbeEntry() instead.  That sets a breakpoint,
+  // at the dyld breakpoint address, with a callback so that when hit,
+  // the dyld structure can be parsed.
+  if (!SetRendezvousBreakpoint()) {
+    // fail
+  }
 }
 
+void DynamicLoaderHexagonDYLD::DidLaunch() {}
+
 /// Checks to see if the target module has changed, updates the target
 /// accordingly and returns the target executable module.
-ModuleSP
-DynamicLoaderHexagonDYLD::GetTargetExecutable()
-{
-    Target &target = m_process->GetTarget();
-    ModuleSP executable = target.GetExecutableModule();
-
-    // There is no executable
-    if (! executable.get())
-        return executable;
-
-    // The target executable file does not exits
-    if (! executable->GetFileSpec().Exists())
-        return executable;
-    
-    // Prep module for loading
-    ModuleSpec module_spec(executable->GetFileSpec(), executable->GetArchitecture());
-    ModuleSP   module_sp  (new Module (module_spec));
-
-    // Check if the executable has changed and set it to the target executable if they differ.
-    if (module_sp.get() && module_sp->GetUUID().IsValid() && executable->GetUUID().IsValid())
-    {
-        // if the executable has changed ??
-        if (module_sp->GetUUID() != executable->GetUUID())
-            executable.reset();
-    }
-    else if (executable->FileHasChanged())
-        executable.reset();
-
-    if ( executable.get( ) )
-        return executable;
-
-    // TODO: What case is this code used?
-    executable = target.GetSharedModule(module_spec);
-    if (executable.get() != target.GetExecutableModulePointer())
-    {
-        // Don't load dependent images since we are in dyld where we will know
-        // and find out about all images that are loaded
-        const bool get_dependent_images = false;
-        target.SetExecutableModule(executable, get_dependent_images);
-    }
-    
+ModuleSP DynamicLoaderHexagonDYLD::GetTargetExecutable() {
+  Target &target = m_process->GetTarget();
+  ModuleSP executable = target.GetExecutableModule();
+
+  // There is no executable
+  if (!executable.get())
+    return executable;
+
+  // The target executable file does not exits
+  if (!executable->GetFileSpec().Exists())
     return executable;
-}
 
-//AD: Needs to be updated?
-Error
-DynamicLoaderHexagonDYLD::CanLoadImage()
-{
-    return Error();
+  // Prep module for loading
+  ModuleSpec module_spec(executable->GetFileSpec(),
+                         executable->GetArchitecture());
+  ModuleSP module_sp(new Module(module_spec));
+
+  // Check if the executable has changed and set it to the target executable if
+  // they differ.
+  if (module_sp.get() && module_sp->GetUUID().IsValid() &&
+      executable->GetUUID().IsValid()) {
+    // if the executable has changed ??
+    if (module_sp->GetUUID() != executable->GetUUID())
+      executable.reset();
+  } else if (executable->FileHasChanged())
+    executable.reset();
+
+  if (executable.get())
+    return executable;
+
+  // TODO: What case is this code used?
+  executable = target.GetSharedModule(module_spec);
+  if (executable.get() != target.GetExecutableModulePointer()) {
+    // Don't load dependent images since we are in dyld where we will know
+    // and find out about all images that are loaded
+    const bool get_dependent_images = false;
+    target.SetExecutableModule(executable, get_dependent_images);
+  }
+
+  return executable;
 }
 
-void
-DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module,
-                                               addr_t link_map_addr,
-                                               addr_t base_addr,
-                                               bool base_addr_is_offset)
-{
-    Target &target = m_process->GetTarget();
-    const SectionList *sections = GetSectionListFromModule(module);
+// AD: Needs to be updated?
+Error DynamicLoaderHexagonDYLD::CanLoadImage() { return Error(); }
 
-    assert(sections && "SectionList missing from loaded module.");
+void DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module,
+                                                    addr_t link_map_addr,
+                                                    addr_t base_addr,
+                                                    bool base_addr_is_offset) {
+  Target &target = m_process->GetTarget();
+  const SectionList *sections = GetSectionListFromModule(module);
 
-    m_loaded_modules[module] = link_map_addr;
+  assert(sections && "SectionList missing from loaded module.");
 
-    const size_t num_sections = sections->GetSize();
+  m_loaded_modules[module] = link_map_addr;
 
-    for (unsigned i = 0; i < num_sections; ++i)
-    {
-        SectionSP section_sp (sections->GetSectionAtIndex(i));
-        lldb::addr_t new_load_addr = section_sp->GetFileAddress() + base_addr;
+  const size_t num_sections = sections->GetSize();
 
-        // AD: 02/05/14
-        //   since our memory map starts from address 0, we must not ignore
-        //   sections that load to address 0.  This violates the reference
-        //   ELF spec, however is used for Hexagon.
+  for (unsigned i = 0; i < num_sections; ++i) {
+    SectionSP section_sp(sections->GetSectionAtIndex(i));
+    lldb::addr_t new_load_addr = section_sp->GetFileAddress() + base_addr;
 
-        // If the file address of the section is zero then this is not an
-        // allocatable/loadable section (property of ELF sh_addr).  Skip it.
-//      if (new_load_addr == base_addr)
-//          continue;
+    // AD: 02/05/14
+    //   since our memory map starts from address 0, we must not ignore
+    //   sections that load to address 0.  This violates the reference
+    //   ELF spec, however is used for Hexagon.
 
-        target.SetSectionLoadAddress(section_sp, new_load_addr);
-    }
+    // If the file address of the section is zero then this is not an
+    // allocatable/loadable section (property of ELF sh_addr).  Skip it.
+    //      if (new_load_addr == base_addr)
+    //          continue;
+
+    target.SetSectionLoadAddress(section_sp, new_load_addr);
+  }
 }
 
 /// Removes the loaded sections from the target in @p module.
 ///
 /// @param module The module to traverse.
-void
-DynamicLoaderHexagonDYLD::UnloadSections(const ModuleSP module)
-{
-    Target &target = m_process->GetTarget();
-    const SectionList *sections = GetSectionListFromModule(module);
+void DynamicLoaderHexagonDYLD::UnloadSections(const ModuleSP module) {
+  Target &target = m_process->GetTarget();
+  const SectionList *sections = GetSectionListFromModule(module);
 
-    assert(sections && "SectionList missing from unloaded module.");
+  assert(sections && "SectionList missing from unloaded module.");
 
-    m_loaded_modules.erase(module);
+  m_loaded_modules.erase(module);
 
-    const size_t num_sections = sections->GetSize();
-    for (size_t i = 0; i < num_sections; ++i)
-    {
-        SectionSP section_sp (sections->GetSectionAtIndex(i));
-        target.SetSectionUnloaded(section_sp);
-    }
+  const size_t num_sections = sections->GetSize();
+  for (size_t i = 0; i < num_sections; ++i) {
+    SectionSP section_sp(sections->GetSectionAtIndex(i));
+    target.SetSectionUnloaded(section_sp);
+  }
 }
 
 // Place a breakpoint on <_rtld_debug_state>
-bool
-DynamicLoaderHexagonDYLD::SetRendezvousBreakpoint()
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-
-    // This is the original code, which want to look in the rendezvous structure
-    // to find the breakpoint address.  Its backwards for us, since we can easily
-    // find the breakpoint address, since it is exported in our executable.
-    // We however know that we cant read the Rendezvous structure until we have hit
-    // the breakpoint once.
-    const ConstString dyldBpName( "_rtld_debug_state" );
-    addr_t break_addr = findSymbolAddress( m_process, dyldBpName );
-
-    Target &target = m_process->GetTarget();
-    
-    // Do not try to set the breakpoint if we don't know where to put it
-    if ( break_addr == LLDB_INVALID_ADDRESS )
-    {
-        if ( log )
-            log->Printf( "Unable to locate _rtld_debug_state breakpoint address" );
-
-        return false;
-    }
-
-    // Save the address of the rendezvous structure
-    m_rendezvous.SetBreakAddress( break_addr );
-
-    // If we haven't set the breakpoint before then set it
-    if (m_dyld_bid == LLDB_INVALID_BREAK_ID)
-    {
-        Breakpoint *dyld_break = target.CreateBreakpoint (break_addr, true, false).get();
-        dyld_break->SetCallback(RendezvousBreakpointHit, this, true);
-        dyld_break->SetBreakpointKind ("shared-library-event");
-        m_dyld_bid = dyld_break->GetID();
-
-        // Make sure our breakpoint is at the right address.
-        assert
-        (
-            target.GetBreakpointByID(m_dyld_bid)->
-            FindLocationByAddress(break_addr)->
-            GetBreakpoint().GetID()
-            == m_dyld_bid
-        );
-
-        if ( log && dyld_break == nullptr )
-            log->Printf( "Failed to create _rtld_debug_state breakpoint" );
-
-        // check we have successfully set bp
-        return (dyld_break != nullptr);
-    }
-    else
-        // rendezvous already set
-        return true;
+bool DynamicLoaderHexagonDYLD::SetRendezvousBreakpoint() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+
+  // This is the original code, which want to look in the rendezvous structure
+  // to find the breakpoint address.  Its backwards for us, since we can easily
+  // find the breakpoint address, since it is exported in our executable.
+  // We however know that we cant read the Rendezvous structure until we have
+  // hit
+  // the breakpoint once.
+  const ConstString dyldBpName("_rtld_debug_state");
+  addr_t break_addr = findSymbolAddress(m_process, dyldBpName);
+
+  Target &target = m_process->GetTarget();
+
+  // Do not try to set the breakpoint if we don't know where to put it
+  if (break_addr == LLDB_INVALID_ADDRESS) {
+    if (log)
+      log->Printf("Unable to locate _rtld_debug_state breakpoint address");
+
+    return false;
+  }
+
+  // Save the address of the rendezvous structure
+  m_rendezvous.SetBreakAddress(break_addr);
+
+  // If we haven't set the breakpoint before then set it
+  if (m_dyld_bid == LLDB_INVALID_BREAK_ID) {
+    Breakpoint *dyld_break =
+        target.CreateBreakpoint(break_addr, true, false).get();
+    dyld_break->SetCallback(RendezvousBreakpointHit, this, true);
+    dyld_break->SetBreakpointKind("shared-library-event");
+    m_dyld_bid = dyld_break->GetID();
+
+    // Make sure our breakpoint is at the right address.
+    assert(target.GetBreakpointByID(m_dyld_bid)
+               ->FindLocationByAddress(break_addr)
+               ->GetBreakpoint()
+               .GetID() == m_dyld_bid);
+
+    if (log && dyld_break == nullptr)
+      log->Printf("Failed to create _rtld_debug_state breakpoint");
+
+    // check we have successfully set bp
+    return (dyld_break != nullptr);
+  } else
+    // rendezvous already set
+    return true;
 }
 
 // We have just hit our breakpoint at <_rtld_debug_state>
-bool
-DynamicLoaderHexagonDYLD::RendezvousBreakpointHit(void *baton, 
-                                                StoppointCallbackContext *context, 
-                                                user_id_t break_id, 
-                                                user_id_t break_loc_id)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+bool DynamicLoaderHexagonDYLD::RendezvousBreakpointHit(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-    if ( log )
-        log->Printf( "Rendezvous breakpoint hit!" );
+  if (log)
+    log->Printf("Rendezvous breakpoint hit!");
 
-    DynamicLoaderHexagonDYLD* dyld_instance = nullptr;
-    dyld_instance = static_cast<DynamicLoaderHexagonDYLD*>(baton);
+  DynamicLoaderHexagonDYLD *dyld_instance = nullptr;
+  dyld_instance = static_cast<DynamicLoaderHexagonDYLD *>(baton);
 
-    // if the dyld_instance is still not valid then
-    // try to locate it on the symbol table
-    if ( !dyld_instance->m_rendezvous.IsValid( ) )
-    {
-        Process *proc = dyld_instance->m_process;
+  // if the dyld_instance is still not valid then
+  // try to locate it on the symbol table
+  if (!dyld_instance->m_rendezvous.IsValid()) {
+    Process *proc = dyld_instance->m_process;
 
-        const ConstString dyldStructName( "_rtld_debug" );
-        addr_t structAddr = findSymbolAddress( proc, dyldStructName );
+    const ConstString dyldStructName("_rtld_debug");
+    addr_t structAddr = findSymbolAddress(proc, dyldStructName);
 
-        if ( structAddr != LLDB_INVALID_ADDRESS )
-        {
-            dyld_instance->m_rendezvous.SetRendezvousAddress( structAddr );
+    if (structAddr != LLDB_INVALID_ADDRESS) {
+      dyld_instance->m_rendezvous.SetRendezvousAddress(structAddr);
 
-            if ( log )
-                log->Printf( "Found _rtld_debug structure @ 0x%08" PRIx64, structAddr );
-        }
-        else
-        {
-            if ( log )
-                log->Printf( "Unable to resolve the _rtld_debug structure" );
-        }
+      if (log)
+        log->Printf("Found _rtld_debug structure @ 0x%08" PRIx64, structAddr);
+    } else {
+      if (log)
+        log->Printf("Unable to resolve the _rtld_debug structure");
     }
+  }
 
-    dyld_instance->RefreshModules();
+  dyld_instance->RefreshModules();
 
-    // Return true to stop the target, false to just let the target run.
-    return dyld_instance->GetStopWhenImagesChange();
+  // Return true to stop the target, false to just let the target run.
+  return dyld_instance->GetStopWhenImagesChange();
 }
 
 /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
 /// of loaded modules.
-void
-DynamicLoaderHexagonDYLD::RefreshModules()
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-
-    if (!m_rendezvous.Resolve())
-        return;
-
-    HexagonDYLDRendezvous::iterator I;
-    HexagonDYLDRendezvous::iterator E;
-
-    ModuleList &loaded_modules = m_process->GetTarget().GetImages();
-
-    if (m_rendezvous.ModulesDidLoad()) 
-    {
-        ModuleList new_modules;
-
-        E = m_rendezvous.loaded_end();
-        for (I = m_rendezvous.loaded_begin(); I != E; ++I)
-        {
-            FileSpec file(I->path.c_str(), true);
-            ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
-            if (module_sp.get())
-            {
-                loaded_modules.AppendIfNeeded( module_sp );
-                new_modules.Append(module_sp);
-            }
-            
-            if (log)
-            {
-                log->Printf( "Target is loading '%s'", I->path.c_str() );
-                if (! module_sp.get() )
-                    log->Printf( "LLDB failed to load '%s'", I->path.c_str() );
-                else
-                    log->Printf( "LLDB successfully loaded '%s'", I->path.c_str() );
-            }
-            
-        }
-        m_process->GetTarget().ModulesDidLoad(new_modules);
+void DynamicLoaderHexagonDYLD::RefreshModules() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+
+  if (!m_rendezvous.Resolve())
+    return;
+
+  HexagonDYLDRendezvous::iterator I;
+  HexagonDYLDRendezvous::iterator E;
+
+  ModuleList &loaded_modules = m_process->GetTarget().GetImages();
+
+  if (m_rendezvous.ModulesDidLoad()) {
+    ModuleList new_modules;
+
+    E = m_rendezvous.loaded_end();
+    for (I = m_rendezvous.loaded_begin(); I != E; ++I) {
+      FileSpec file(I->path, true);
+      ModuleSP module_sp =
+          LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
+      if (module_sp.get()) {
+        loaded_modules.AppendIfNeeded(module_sp);
+        new_modules.Append(module_sp);
+      }
+
+      if (log) {
+        log->Printf("Target is loading '%s'", I->path.c_str());
+        if (!module_sp.get())
+          log->Printf("LLDB failed to load '%s'", I->path.c_str());
+        else
+          log->Printf("LLDB successfully loaded '%s'", I->path.c_str());
+      }
     }
-    
-    if (m_rendezvous.ModulesDidUnload())
-    {
-        ModuleList old_modules;
-
-        E = m_rendezvous.unloaded_end();
-        for (I = m_rendezvous.unloaded_begin(); I != E; ++I)
-        {
-            FileSpec file(I->path.c_str(), true);
-            ModuleSpec module_spec(file);
-            ModuleSP module_sp = loaded_modules.FindFirstModule (module_spec);
-
-            if (module_sp.get())
-            {
-                old_modules.Append(module_sp);
-                UnloadSections(module_sp);
-            }
-
-            if (log)
-                log->Printf( "Target is unloading '%s'", I->path.c_str() );
-
-        }
-        loaded_modules.Remove(old_modules);
-        m_process->GetTarget().ModulesDidUnload(old_modules, false);
+    m_process->GetTarget().ModulesDidLoad(new_modules);
+  }
+
+  if (m_rendezvous.ModulesDidUnload()) {
+    ModuleList old_modules;
+
+    E = m_rendezvous.unloaded_end();
+    for (I = m_rendezvous.unloaded_begin(); I != E; ++I) {
+      FileSpec file(I->path, true);
+      ModuleSpec module_spec(file);
+      ModuleSP module_sp = loaded_modules.FindFirstModule(module_spec);
+
+      if (module_sp.get()) {
+        old_modules.Append(module_sp);
+        UnloadSections(module_sp);
+      }
+
+      if (log)
+        log->Printf("Target is unloading '%s'", I->path.c_str());
     }
+    loaded_modules.Remove(old_modules);
+    m_process->GetTarget().ModulesDidUnload(old_modules, false);
+  }
 }
 
-//AD:	This is very different to the Static Loader code.
+// AD:	This is very different to the Static Loader code.
 //		It may be wise to look over this and its relation to stack
 //		unwinding.
 ThreadPlanSP
-DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
-{
-    ThreadPlanSP thread_plan_sp;
-
-    StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
-    const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol);
-    Symbol *sym = context.symbol;
-
-    if (sym == NULL || !sym->IsTrampoline())
-        return thread_plan_sp;
-
-    const ConstString sym_name = sym->GetMangled().GetName(lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
-    if (!sym_name)
-        return thread_plan_sp;
-
-    SymbolContextList target_symbols;
-    Target &target = thread.GetProcess()->GetTarget();
-    const ModuleList &images = target.GetImages();
-
-    images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
-    size_t num_targets = target_symbols.GetSize();
-    if (!num_targets)
-        return thread_plan_sp;
-
-    typedef std::vector<lldb::addr_t> AddressVector;
-    AddressVector addrs;
-    for (size_t i = 0; i < num_targets; ++i)
-    {
-        SymbolContext context;
-        AddressRange range;
-        if (target_symbols.GetContextAtIndex(i, context))
-        {
-            context.GetAddressRange(eSymbolContextEverything, 0, false, range);
-            lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
-            if (addr != LLDB_INVALID_ADDRESS)
-                addrs.push_back(addr);
-        }
-    }
+DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread,
+                                                       bool stop) {
+  ThreadPlanSP thread_plan_sp;
 
-    if (addrs.size() > 0) 
-    {
-        AddressVector::iterator start = addrs.begin();
-        AddressVector::iterator end = addrs.end();
+  StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
+  const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol);
+  Symbol *sym = context.symbol;
 
-        std::sort(start, end);
-        addrs.erase(std::unique(start, end), end);
-        thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
-    }
+  if (sym == NULL || !sym->IsTrampoline())
+    return thread_plan_sp;
+
+  const ConstString sym_name = sym->GetMangled().GetName(
+      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
+  if (!sym_name)
+    return thread_plan_sp;
+
+  SymbolContextList target_symbols;
+  Target &target = thread.GetProcess()->GetTarget();
+  const ModuleList &images = target.GetImages();
 
+  images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
+  size_t num_targets = target_symbols.GetSize();
+  if (!num_targets)
     return thread_plan_sp;
+
+  typedef std::vector<lldb::addr_t> AddressVector;
+  AddressVector addrs;
+  for (size_t i = 0; i < num_targets; ++i) {
+    SymbolContext context;
+    AddressRange range;
+    if (target_symbols.GetContextAtIndex(i, context)) {
+      context.GetAddressRange(eSymbolContextEverything, 0, false, range);
+      lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
+      if (addr != LLDB_INVALID_ADDRESS)
+        addrs.push_back(addr);
+    }
+  }
+
+  if (addrs.size() > 0) {
+    AddressVector::iterator start = addrs.begin();
+    AddressVector::iterator end = addrs.end();
+
+    std::sort(start, end);
+    addrs.erase(std::unique(start, end), end);
+    thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
+  }
+
+  return thread_plan_sp;
 }
 
 /// Helper for the entry breakpoint callback.  Resolves the load addresses
 /// of all dependent modules.
-void
-DynamicLoaderHexagonDYLD::LoadAllCurrentModules()
-{
-    HexagonDYLDRendezvous::iterator I;
-    HexagonDYLDRendezvous::iterator E;
-    ModuleList module_list;
-    
-    if (!m_rendezvous.Resolve())
-    {
-        Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-        if (log)
-            log->Printf("DynamicLoaderHexagonDYLD::%s unable to resolve rendezvous address", __FUNCTION__);
-        return;
-    }
+void DynamicLoaderHexagonDYLD::LoadAllCurrentModules() {
+  HexagonDYLDRendezvous::iterator I;
+  HexagonDYLDRendezvous::iterator E;
+  ModuleList module_list;
 
-    // The rendezvous class doesn't enumerate the main module, so track
-    // that ourselves here.
-    ModuleSP executable = GetTargetExecutable();
-    m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
-
-
-    for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
-    {
-        const char *module_path = I->path.c_str();
-        FileSpec file(module_path, false);
-        ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
-        if (module_sp.get())
-        {
-            module_list.Append(module_sp);
-        }
-        else
-        {
-            Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-            if (log)
-                log->Printf("DynamicLoaderHexagonDYLD::%s failed loading module %s at 0x%" PRIx64,
-                            __FUNCTION__, module_path, I->base_addr);
-        }
+  if (!m_rendezvous.Resolve()) {
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+    if (log)
+      log->Printf(
+          "DynamicLoaderHexagonDYLD::%s unable to resolve rendezvous address",
+          __FUNCTION__);
+    return;
+  }
+
+  // The rendezvous class doesn't enumerate the main module, so track
+  // that ourselves here.
+  ModuleSP executable = GetTargetExecutable();
+  m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
+
+  for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) {
+    const char *module_path = I->path.c_str();
+    FileSpec file(module_path, false);
+    ModuleSP module_sp =
+        LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
+    if (module_sp.get()) {
+      module_list.Append(module_sp);
+    } else {
+      Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+      if (log)
+        log->Printf("DynamicLoaderHexagonDYLD::%s failed loading module %s at "
+                    "0x%" PRIx64,
+                    __FUNCTION__, module_path, I->base_addr);
     }
+  }
 
-    m_process->GetTarget().ModulesDidLoad(module_list);
+  m_process->GetTarget().ModulesDidLoad(module_list);
 }
 
 /// Computes a value for m_load_offset returning the computed address on
 /// success and LLDB_INVALID_ADDRESS on failure.
-addr_t
-DynamicLoaderHexagonDYLD::ComputeLoadOffset()
-{
-    // Here we could send a GDB packet to know the load offset
-    //
-    // send:    $qOffsets#4b
-    // get:     Text=0;Data=0;Bss=0
-    // 
-    // Currently qOffsets is not supported by pluginProcessGDBRemote
-    //
-    return 0;
+addr_t DynamicLoaderHexagonDYLD::ComputeLoadOffset() {
+  // Here we could send a GDB packet to know the load offset
+  //
+  // send:    $qOffsets#4b
+  // get:     Text=0;Data=0;Bss=0
+  //
+  // Currently qOffsets is not supported by pluginProcessGDBRemote
+  //
+  return 0;
 }
 
 // Here we must try to read the entry point directly from
@@ -596,100 +524,97 @@ DynamicLoaderHexagonDYLD::ComputeLoadOffset()
 // an alternative is to look at the PC if we can be sure
 // that we have connected when the process is at the entry point.
 // I dont think that is reliable for us.
-addr_t
-DynamicLoaderHexagonDYLD::GetEntryPoint()
-{
-    if (m_entry_point != LLDB_INVALID_ADDRESS)
-        return m_entry_point;
-    // check we have a valid process
-    if ( m_process == nullptr )
-        return LLDB_INVALID_ADDRESS;
-    // Get the current executable module
-    Module & module = *( m_process->GetTarget( ).GetExecutableModule( ).get( ) );
-    // Get the object file (elf file) for this module
-    lldb_private::ObjectFile &object = *( module.GetObjectFile( ) );
-    // Check if the file is executable (ie, not shared object or relocatable)
-    if ( object.IsExecutable() )
-    {
-        // Get the entry point address for this object
-        lldb_private::Address entry = object.GetEntryPointAddress( );
-        // Return the entry point address
-        return entry.GetFileAddress( );
-    }
-    // No idea so back out
+addr_t DynamicLoaderHexagonDYLD::GetEntryPoint() {
+  if (m_entry_point != LLDB_INVALID_ADDRESS)
+    return m_entry_point;
+  // check we have a valid process
+  if (m_process == nullptr)
     return LLDB_INVALID_ADDRESS;
+  // Get the current executable module
+  Module &module = *(m_process->GetTarget().GetExecutableModule().get());
+  // Get the object file (elf file) for this module
+  lldb_private::ObjectFile &object = *(module.GetObjectFile());
+  // Check if the file is executable (ie, not shared object or relocatable)
+  if (object.IsExecutable()) {
+    // Get the entry point address for this object
+    lldb_private::Address entry = object.GetEntryPointAddress();
+    // Return the entry point address
+    return entry.GetFileAddress();
+  }
+  // No idea so back out
+  return LLDB_INVALID_ADDRESS;
 }
 
-const SectionList *
-DynamicLoaderHexagonDYLD::GetSectionListFromModule(const ModuleSP module) const
-{
-    SectionList *sections = nullptr;
-    if (module.get())
-    {
-        ObjectFile *obj_file = module->GetObjectFile();
-        if (obj_file)
-        {
-            sections = obj_file->GetSectionList();
-        }
+const SectionList *DynamicLoaderHexagonDYLD::GetSectionListFromModule(
+    const ModuleSP module) const {
+  SectionList *sections = nullptr;
+  if (module.get()) {
+    ObjectFile *obj_file = module->GetObjectFile();
+    if (obj_file) {
+      sections = obj_file->GetSectionList();
     }
-    return sections;
+  }
+  return sections;
 }
 
-static int ReadInt(Process *process, addr_t addr)
-{
-    Error error;
-    int value = (int)process->ReadUnsignedIntegerFromMemory(addr, sizeof(uint32_t), 0, error);
-    if (error.Fail())
-        return -1;
-    else
-        return value;
+static int ReadInt(Process *process, addr_t addr) {
+  Error error;
+  int value = (int)process->ReadUnsignedIntegerFromMemory(
+      addr, sizeof(uint32_t), 0, error);
+  if (error.Fail())
+    return -1;
+  else
+    return value;
 }
 
 lldb::addr_t
-DynamicLoaderHexagonDYLD::GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread,
-                                             lldb::addr_t tls_file_addr)
-{
-    auto it = m_loaded_modules.find (module);
-    if (it == m_loaded_modules.end())
-        return LLDB_INVALID_ADDRESS;
-
-    addr_t link_map = it->second;
-    if (link_map == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-
-    const HexagonDYLDRendezvous::ThreadInfo &metadata = m_rendezvous.GetThreadInfo();
-    if (!metadata.valid)
-        return LLDB_INVALID_ADDRESS;
-
-    // Get the thread pointer.
-    addr_t tp = thread->GetThreadPointer ();
-    if (tp == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-
-    // Find the module's modid.
-    int modid = ReadInt (m_process, link_map + metadata.modid_offset);
-    if (modid == -1)
-        return LLDB_INVALID_ADDRESS;
-
-    // Lookup the DTV stucture for this thread.
-    addr_t dtv_ptr = tp + metadata.dtv_offset;
-    addr_t dtv = ReadPointer (dtv_ptr);
-    if (dtv == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-
-    // Find the TLS block for this module.
-    addr_t dtv_slot = dtv + metadata.dtv_slot_size*modid;
-    addr_t tls_block = ReadPointer (dtv_slot + metadata.tls_offset);
-
-    Module *mod = module.get();
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    if (log)
-        log->Printf("DynamicLoaderHexagonDYLD::Performed TLS lookup: "
-                    "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64 ", modid=%i, tls_block=0x%" PRIx64,
-                    mod->GetObjectName().AsCString(""), link_map, tp, modid, tls_block);
-
-    if (tls_block == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-    else
-        return tls_block + tls_file_addr;
+DynamicLoaderHexagonDYLD::GetThreadLocalData(const lldb::ModuleSP module,
+                                             const lldb::ThreadSP thread,
+                                             lldb::addr_t tls_file_addr) {
+  auto it = m_loaded_modules.find(module);
+  if (it == m_loaded_modules.end())
+    return LLDB_INVALID_ADDRESS;
+
+  addr_t link_map = it->second;
+  if (link_map == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+
+  const HexagonDYLDRendezvous::ThreadInfo &metadata =
+      m_rendezvous.GetThreadInfo();
+  if (!metadata.valid)
+    return LLDB_INVALID_ADDRESS;
+
+  // Get the thread pointer.
+  addr_t tp = thread->GetThreadPointer();
+  if (tp == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+
+  // Find the module's modid.
+  int modid = ReadInt(m_process, link_map + metadata.modid_offset);
+  if (modid == -1)
+    return LLDB_INVALID_ADDRESS;
+
+  // Lookup the DTV structure for this thread.
+  addr_t dtv_ptr = tp + metadata.dtv_offset;
+  addr_t dtv = ReadPointer(dtv_ptr);
+  if (dtv == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+
+  // Find the TLS block for this module.
+  addr_t dtv_slot = dtv + metadata.dtv_slot_size * modid;
+  addr_t tls_block = ReadPointer(dtv_slot + metadata.tls_offset);
+
+  Module *mod = module.get();
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  if (log)
+    log->Printf("DynamicLoaderHexagonDYLD::Performed TLS lookup: "
+                "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64
+                ", modid=%i, tls_block=0x%" PRIx64,
+                mod->GetObjectName().AsCString(""), link_map, tp, modid,
+                tls_block);
+
+  if (tls_block == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+  else
+    return tls_block + tls_file_addr;
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h
index 67c3288..05709d0 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h
@@ -1,4 +1,4 @@
-//===-- DynamicLoaderHexagon.h ----------------------------------*- C++ -*-===//
+//===-- DynamicLoaderHexagonDYLD.h ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -19,150 +19,129 @@
 
 #include "HexagonDYLDRendezvous.h"
 
-class DynamicLoaderHexagonDYLD : public lldb_private::DynamicLoader
-{
+class DynamicLoaderHexagonDYLD : public lldb_private::DynamicLoader {
 public:
-    DynamicLoaderHexagonDYLD(lldb_private::Process *process);
+  DynamicLoaderHexagonDYLD(lldb_private::Process *process);
 
-    ~DynamicLoaderHexagonDYLD() override;
+  ~DynamicLoaderHexagonDYLD() override;
 
-    static void
-    Initialize();
+  static void Initialize();
 
-    static void
-    Terminate();
+  static void Terminate();
 
-    static lldb_private::ConstString
-    GetPluginNameStatic();
+  static lldb_private::ConstString GetPluginNameStatic();
 
-    static const char *
-    GetPluginDescriptionStatic();
+  static const char *GetPluginDescriptionStatic();
 
-    static lldb_private::DynamicLoader *
-    CreateInstance(lldb_private::Process *process, bool force);
+  static lldb_private::DynamicLoader *
+  CreateInstance(lldb_private::Process *process, bool force);
 
-    //------------------------------------------------------------------
-    // DynamicLoader protocol
-    //------------------------------------------------------------------
+  //------------------------------------------------------------------
+  // DynamicLoader protocol
+  //------------------------------------------------------------------
 
-    void
-    DidAttach() override;
+  void DidAttach() override;
 
-    void
-    DidLaunch() override;
+  void DidLaunch() override;
 
-    lldb::ThreadPlanSP
-    GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
-                                 bool stop_others) override;
+  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
+                                                  bool stop_others) override;
 
-    lldb_private::Error
-    CanLoadImage() override;
+  lldb_private::Error CanLoadImage() override;
 
-    lldb::addr_t
-    GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread, lldb::addr_t tls_file_addr) override;
+  lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
+                                  const lldb::ThreadSP thread,
+                                  lldb::addr_t tls_file_addr) override;
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
 
-    uint32_t
-    GetPluginVersion() override;
+  uint32_t GetPluginVersion() override;
 
 protected:
-    /// Runtime linker rendezvous structure.
-    HexagonDYLDRendezvous m_rendezvous;
-
-    /// Virtual load address of the inferior process.
-    lldb::addr_t m_load_offset;
-
-    /// Virtual entry address of the inferior process.
-    lldb::addr_t m_entry_point;
-
-    /// Rendezvous breakpoint.
-    lldb::break_id_t m_dyld_bid;
-
-    /// Loaded module list. (link map for each module)
-    std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>> m_loaded_modules;
-
-    /// Enables a breakpoint on a function called by the runtime
-    /// linker each time a module is loaded or unloaded.
-    bool
-    SetRendezvousBreakpoint();
-
-    /// Callback routine which updates the current list of loaded modules based
-    /// on the information supplied by the runtime linker.
-    static bool
-    RendezvousBreakpointHit(void *baton, 
-                            lldb_private::StoppointCallbackContext *context, 
-                            lldb::user_id_t break_id, 
-                            lldb::user_id_t break_loc_id);
-    
-    /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
-    /// of loaded modules.
-    void
-    RefreshModules();
-
-    /// Updates the load address of every allocatable section in @p module.
-    ///
-    /// @param module The module to traverse.
-    ///
-    /// @param link_map_addr The virtual address of the link map for the @p module.
-    ///
-    /// @param base_addr The virtual base address @p module is loaded at.
-    void
-    UpdateLoadedSections(lldb::ModuleSP module,
-                         lldb::addr_t link_map_addr,
-                         lldb::addr_t base_addr,
-                         bool base_addr_is_offset) override;
-
-    /// Removes the loaded sections from the target in @p module.
-    ///
-    /// @param module The module to traverse.
-    void
-    UnloadSections(const lldb::ModuleSP module) override;
-
-    /// Callback routine invoked when we hit the breakpoint on process entry.
-    ///
-    /// This routine is responsible for resolving the load addresses of all
-    /// dependent modules required by the inferior and setting up the rendezvous
-    /// breakpoint.
-    static bool
-    EntryBreakpointHit(void *baton, 
-                       lldb_private::StoppointCallbackContext *context, 
-                       lldb::user_id_t break_id, 
-                       lldb::user_id_t break_loc_id);
-
-    /// Helper for the entry breakpoint callback.  Resolves the load addresses
-    /// of all dependent modules.
-    void
-    LoadAllCurrentModules();
-
-    /// Computes a value for m_load_offset returning the computed address on
-    /// success and LLDB_INVALID_ADDRESS on failure.
-    lldb::addr_t
-    ComputeLoadOffset();
-
-    /// Computes a value for m_entry_point returning the computed address on
-    /// success and LLDB_INVALID_ADDRESS on failure.
-    lldb::addr_t
-    GetEntryPoint();
-
-    /// Checks to see if the target module has changed, updates the target
-    /// accordingly and returns the target executable module.
-    lldb::ModuleSP
-    GetTargetExecutable();
-
-    /// return the address of the Rendezvous breakpoint
-    lldb::addr_t
-    FindRendezvousBreakpointAddress( );
+  /// Runtime linker rendezvous structure.
+  HexagonDYLDRendezvous m_rendezvous;
+
+  /// Virtual load address of the inferior process.
+  lldb::addr_t m_load_offset;
+
+  /// Virtual entry address of the inferior process.
+  lldb::addr_t m_entry_point;
+
+  /// Rendezvous breakpoint.
+  lldb::break_id_t m_dyld_bid;
+
+  /// Loaded module list. (link map for each module)
+  std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>>
+      m_loaded_modules;
+
+  /// Enables a breakpoint on a function called by the runtime
+  /// linker each time a module is loaded or unloaded.
+  bool SetRendezvousBreakpoint();
+
+  /// Callback routine which updates the current list of loaded modules based
+  /// on the information supplied by the runtime linker.
+  static bool RendezvousBreakpointHit(
+      void *baton, lldb_private::StoppointCallbackContext *context,
+      lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+
+  /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
+  /// of loaded modules.
+  void RefreshModules();
+
+  /// Updates the load address of every allocatable section in @p module.
+  ///
+  /// @param module The module to traverse.
+  ///
+  /// @param link_map_addr The virtual address of the link map for the @p
+  /// module.
+  ///
+  /// @param base_addr The virtual base address @p module is loaded at.
+  void UpdateLoadedSections(lldb::ModuleSP module, lldb::addr_t link_map_addr,
+                            lldb::addr_t base_addr,
+                            bool base_addr_is_offset) override;
+
+  /// Removes the loaded sections from the target in @p module.
+  ///
+  /// @param module The module to traverse.
+  void UnloadSections(const lldb::ModuleSP module) override;
+
+  /// Callback routine invoked when we hit the breakpoint on process entry.
+  ///
+  /// This routine is responsible for resolving the load addresses of all
+  /// dependent modules required by the inferior and setting up the rendezvous
+  /// breakpoint.
+  static bool
+  EntryBreakpointHit(void *baton,
+                     lldb_private::StoppointCallbackContext *context,
+                     lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+
+  /// Helper for the entry breakpoint callback.  Resolves the load addresses
+  /// of all dependent modules.
+  void LoadAllCurrentModules();
+
+  /// Computes a value for m_load_offset returning the computed address on
+  /// success and LLDB_INVALID_ADDRESS on failure.
+  lldb::addr_t ComputeLoadOffset();
+
+  /// Computes a value for m_entry_point returning the computed address on
+  /// success and LLDB_INVALID_ADDRESS on failure.
+  lldb::addr_t GetEntryPoint();
+
+  /// Checks to see if the target module has changed, updates the target
+  /// accordingly and returns the target executable module.
+  lldb::ModuleSP GetTargetExecutable();
+
+  /// return the address of the Rendezvous breakpoint
+  lldb::addr_t FindRendezvousBreakpointAddress();
 
 private:
-    const lldb_private::SectionList *
-    GetSectionListFromModule(const lldb::ModuleSP module) const;
+  const lldb_private::SectionList *
+  GetSectionListFromModule(const lldb::ModuleSP module) const;
 
-    DISALLOW_COPY_AND_ASSIGN(DynamicLoaderHexagonDYLD);
+  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderHexagonDYLD);
 };
 
 #endif // liblldb_DynamicLoaderHexagonDYLD_h_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp
index 61f9b3d..da0edc8 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp
@@ -30,375 +30,343 @@ using namespace lldb_private;
 
 /// Locates the address of the rendezvous structure.  Returns the address on
 /// success and LLDB_INVALID_ADDRESS on failure.
-static addr_t
-ResolveRendezvousAddress(Process *process)
-{
-    addr_t info_location;
-    addr_t info_addr;
-    Error error;
+static addr_t ResolveRendezvousAddress(Process *process) {
+  addr_t info_location;
+  addr_t info_addr;
+  Error error;
 
-    info_location = process->GetImageInfoAddress();
+  info_location = process->GetImageInfoAddress();
 
-    if (info_location == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
+  if (info_location == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
 
-    info_addr = process->ReadPointerFromMemory(info_location, error);
-    if (error.Fail())
-        return LLDB_INVALID_ADDRESS;
+  info_addr = process->ReadPointerFromMemory(info_location, error);
+  if (error.Fail())
+    return LLDB_INVALID_ADDRESS;
 
-    if (info_addr == 0)
-        return LLDB_INVALID_ADDRESS;
+  if (info_addr == 0)
+    return LLDB_INVALID_ADDRESS;
 
-    return info_addr;
+  return info_addr;
 }
 
 HexagonDYLDRendezvous::HexagonDYLDRendezvous(Process *process)
-    : m_process(process),
-      m_rendezvous_addr(LLDB_INVALID_ADDRESS),
-      m_current(),
-      m_previous(),
-      m_soentries(),
-      m_added_soentries(),
-      m_removed_soentries()
-{
-    m_thread_info.valid = false;
-
-    // Cache a copy of the executable path
-    if (m_process)
-    {
-        Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
-        if (exe_mod)
-            exe_mod->GetFileSpec().GetPath(m_exe_path, PATH_MAX);
-    }
+    : m_process(process), m_rendezvous_addr(LLDB_INVALID_ADDRESS), m_current(),
+      m_previous(), m_soentries(), m_added_soentries(), m_removed_soentries() {
+  m_thread_info.valid = false;
+
+  // Cache a copy of the executable path
+  if (m_process) {
+    Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
+    if (exe_mod)
+      exe_mod->GetFileSpec().GetPath(m_exe_path, PATH_MAX);
+  }
 }
 
-bool
-HexagonDYLDRendezvous::Resolve()
-{
-    const size_t word_size = 4;
-    Rendezvous info;
-    size_t address_size;
-    size_t padding;
-    addr_t info_addr;
-    addr_t cursor;
+bool HexagonDYLDRendezvous::Resolve() {
+  const size_t word_size = 4;
+  Rendezvous info;
+  size_t address_size;
+  size_t padding;
+  addr_t info_addr;
+  addr_t cursor;
 
-    address_size = m_process->GetAddressByteSize();
-    padding = address_size - word_size;
+  address_size = m_process->GetAddressByteSize();
+  padding = address_size - word_size;
 
-    if (m_rendezvous_addr == LLDB_INVALID_ADDRESS)
-        cursor = info_addr = ResolveRendezvousAddress(m_process);
-    else
-        cursor = info_addr = m_rendezvous_addr;
-    
-    if (cursor == LLDB_INVALID_ADDRESS)
-        return false;
+  if (m_rendezvous_addr == LLDB_INVALID_ADDRESS)
+    cursor = info_addr = ResolveRendezvousAddress(m_process);
+  else
+    cursor = info_addr = m_rendezvous_addr;
 
-    if (!(cursor = ReadWord(cursor, &info.version, word_size)))
-        return false;
+  if (cursor == LLDB_INVALID_ADDRESS)
+    return false;
 
-    if (!(cursor = ReadPointer(cursor + padding, &info.map_addr)))
-        return false;
+  if (!(cursor = ReadWord(cursor, &info.version, word_size)))
+    return false;
+
+  if (!(cursor = ReadPointer(cursor + padding, &info.map_addr)))
+    return false;
 
-    if (!(cursor = ReadPointer(cursor, &info.brk)))
-        return false;
+  if (!(cursor = ReadPointer(cursor, &info.brk)))
+    return false;
 
-    if (!(cursor = ReadWord(cursor, &info.state, word_size)))
-        return false;
+  if (!(cursor = ReadWord(cursor, &info.state, word_size)))
+    return false;
 
-    if (!(cursor = ReadPointer(cursor + padding, &info.ldbase)))
-        return false;
+  if (!(cursor = ReadPointer(cursor + padding, &info.ldbase)))
+    return false;
 
-    // The rendezvous was successfully read.  Update our internal state.
-    m_rendezvous_addr = info_addr;
-    m_previous = m_current;
-    m_current = info;
+  // The rendezvous was successfully read.  Update our internal state.
+  m_rendezvous_addr = info_addr;
+  m_previous = m_current;
+  m_current = info;
 
-    return UpdateSOEntries();
+  return UpdateSOEntries();
 }
 
-void
-HexagonDYLDRendezvous::SetRendezvousAddress( lldb::addr_t addr )
-{
-    m_rendezvous_addr = addr;
+void HexagonDYLDRendezvous::SetRendezvousAddress(lldb::addr_t addr) {
+  m_rendezvous_addr = addr;
 }
 
-bool
-HexagonDYLDRendezvous::IsValid()
-{
-    return m_rendezvous_addr != LLDB_INVALID_ADDRESS;
+bool HexagonDYLDRendezvous::IsValid() {
+  return m_rendezvous_addr != LLDB_INVALID_ADDRESS;
 }
 
-bool
-HexagonDYLDRendezvous::UpdateSOEntries()
-{
-    SOEntry entry;
-
-    if (m_current.map_addr == 0)
-        return false;
-
-    // When the previous and current states are consistent this is the first
-    // time we have been asked to update.  Just take a snapshot of the currently
-    // loaded modules.
-    if (m_previous.state == eConsistent && m_current.state == eConsistent) 
-        return TakeSnapshot(m_soentries);
-
-    // If we are about to add or remove a shared object clear out the current
-    // state and take a snapshot of the currently loaded images.
-    if (m_current.state == eAdd || m_current.state == eDelete)
-    {
-        // this is a fudge so that we can clear the assert below.
-        m_previous.state = eConsistent;
-        // We hit this assert on the 2nd run of this function after running the calc example
-        assert(m_previous.state == eConsistent);
-        m_soentries.clear();
-        m_added_soentries.clear();
-        m_removed_soentries.clear();
-        return TakeSnapshot(m_soentries);
-    }
-    assert(m_current.state == eConsistent);
-
-    // Otherwise check the previous state to determine what to expect and update
-    // accordingly.
-    if (m_previous.state == eAdd)
-        return UpdateSOEntriesForAddition();
-    else if (m_previous.state == eDelete)
-        return UpdateSOEntriesForDeletion();
+bool HexagonDYLDRendezvous::UpdateSOEntries() {
+  SOEntry entry;
 
+  if (m_current.map_addr == 0)
     return false;
+
+  // When the previous and current states are consistent this is the first
+  // time we have been asked to update.  Just take a snapshot of the currently
+  // loaded modules.
+  if (m_previous.state == eConsistent && m_current.state == eConsistent)
+    return TakeSnapshot(m_soentries);
+
+  // If we are about to add or remove a shared object clear out the current
+  // state and take a snapshot of the currently loaded images.
+  if (m_current.state == eAdd || m_current.state == eDelete) {
+    // this is a fudge so that we can clear the assert below.
+    m_previous.state = eConsistent;
+    // We hit this assert on the 2nd run of this function after running the calc
+    // example
+    assert(m_previous.state == eConsistent);
+    m_soentries.clear();
+    m_added_soentries.clear();
+    m_removed_soentries.clear();
+    return TakeSnapshot(m_soentries);
+  }
+  assert(m_current.state == eConsistent);
+
+  // Otherwise check the previous state to determine what to expect and update
+  // accordingly.
+  if (m_previous.state == eAdd)
+    return UpdateSOEntriesForAddition();
+  else if (m_previous.state == eDelete)
+    return UpdateSOEntriesForDeletion();
+
+  return false;
 }
- 
-bool
-HexagonDYLDRendezvous::UpdateSOEntriesForAddition()
-{
-    SOEntry entry;
-    iterator pos;
-
-    assert(m_previous.state == eAdd);
-
-    if (m_current.map_addr == 0)
-        return false;
-
-    for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
-    {
-        if (!ReadSOEntryFromMemory(cursor, entry))
-            return false;
-
-        // Only add shared libraries and not the executable.
-        // On Linux this is indicated by an empty path in the entry.
-        // On FreeBSD it is the name of the executable.
-        if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
-            continue;
-
-        pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
-        if (pos == m_soentries.end())
-        {
-            m_soentries.push_back(entry);
-            m_added_soentries.push_back(entry);
-        }
+
+bool HexagonDYLDRendezvous::UpdateSOEntriesForAddition() {
+  SOEntry entry;
+  iterator pos;
+
+  assert(m_previous.state == eAdd);
+
+  if (m_current.map_addr == 0)
+    return false;
+
+  for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next) {
+    if (!ReadSOEntryFromMemory(cursor, entry))
+      return false;
+
+    // Only add shared libraries and not the executable.
+    // On Linux this is indicated by an empty path in the entry.
+    // On FreeBSD it is the name of the executable.
+    if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
+      continue;
+
+    pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
+    if (pos == m_soentries.end()) {
+      m_soentries.push_back(entry);
+      m_added_soentries.push_back(entry);
     }
+  }
 
-    return true;
+  return true;
 }
 
-bool
-HexagonDYLDRendezvous::UpdateSOEntriesForDeletion()
-{
-    SOEntryList entry_list;
-    iterator pos;
+bool HexagonDYLDRendezvous::UpdateSOEntriesForDeletion() {
+  SOEntryList entry_list;
+  iterator pos;
 
-    assert(m_previous.state == eDelete);
+  assert(m_previous.state == eDelete);
 
-    if (!TakeSnapshot(entry_list))
-        return false;
+  if (!TakeSnapshot(entry_list))
+    return false;
 
-    for (iterator I = begin(); I != end(); ++I)
-    {
-        pos = std::find(entry_list.begin(), entry_list.end(), *I);
-        if (pos == entry_list.end())
-            m_removed_soentries.push_back(*I);
-    }
+  for (iterator I = begin(); I != end(); ++I) {
+    pos = std::find(entry_list.begin(), entry_list.end(), *I);
+    if (pos == entry_list.end())
+      m_removed_soentries.push_back(*I);
+  }
 
-    m_soentries = entry_list;
-    return true;
+  m_soentries = entry_list;
+  return true;
 }
 
-bool
-HexagonDYLDRendezvous::TakeSnapshot(SOEntryList &entry_list)
-{
-    SOEntry entry;
+bool HexagonDYLDRendezvous::TakeSnapshot(SOEntryList &entry_list) {
+  SOEntry entry;
 
-    if (m_current.map_addr == 0)
-        return false;
+  if (m_current.map_addr == 0)
+    return false;
 
-    for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
-    {
-        if (!ReadSOEntryFromMemory(cursor, entry))
-            return false;
+  for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next) {
+    if (!ReadSOEntryFromMemory(cursor, entry))
+      return false;
 
-        // Only add shared libraries and not the executable.
-        // On Linux this is indicated by an empty path in the entry.
-        // On FreeBSD it is the name of the executable.
-        if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
-            continue;
+    // Only add shared libraries and not the executable.
+    // On Linux this is indicated by an empty path in the entry.
+    // On FreeBSD it is the name of the executable.
+    if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
+      continue;
 
-        entry_list.push_back(entry);
-    }
+    entry_list.push_back(entry);
+  }
 
-    return true;
+  return true;
 }
 
-addr_t
-HexagonDYLDRendezvous::ReadWord(addr_t addr, uint64_t *dst, size_t size)
-{
-    Error error;
+addr_t HexagonDYLDRendezvous::ReadWord(addr_t addr, uint64_t *dst,
+                                       size_t size) {
+  Error error;
 
-    *dst = m_process->ReadUnsignedIntegerFromMemory(addr, size, 0, error);
-    if (error.Fail())
-        return 0;
+  *dst = m_process->ReadUnsignedIntegerFromMemory(addr, size, 0, error);
+  if (error.Fail())
+    return 0;
 
-    return addr + size;
+  return addr + size;
 }
 
-addr_t
-HexagonDYLDRendezvous::ReadPointer(addr_t addr, addr_t *dst)
-{
-    Error error;
- 
-    *dst = m_process->ReadPointerFromMemory(addr, error);
-    if (error.Fail())
-        return 0;
+addr_t HexagonDYLDRendezvous::ReadPointer(addr_t addr, addr_t *dst) {
+  Error error;
+
+  *dst = m_process->ReadPointerFromMemory(addr, error);
+  if (error.Fail())
+    return 0;
 
-    return addr + m_process->GetAddressByteSize();
+  return addr + m_process->GetAddressByteSize();
 }
 
-std::string
-HexagonDYLDRendezvous::ReadStringFromMemory(addr_t addr)
-{
-    std::string str;
-    Error error;
-    size_t size;
-    char c;
-
-    if (addr == LLDB_INVALID_ADDRESS)
-        return std::string();
-
-    for (;;) {
-        size = m_process->DoReadMemory(addr, &c, 1, error);
-        if (size != 1 || error.Fail())
-            return std::string();
-        if (c == 0)
-            break;
-        else {
-            str.push_back(c);
-            addr++;
-        }
+std::string HexagonDYLDRendezvous::ReadStringFromMemory(addr_t addr) {
+  std::string str;
+  Error error;
+  size_t size;
+  char c;
+
+  if (addr == LLDB_INVALID_ADDRESS)
+    return std::string();
+
+  for (;;) {
+    size = m_process->DoReadMemory(addr, &c, 1, error);
+    if (size != 1 || error.Fail())
+      return std::string();
+    if (c == 0)
+      break;
+    else {
+      str.push_back(c);
+      addr++;
     }
+  }
 
-    return str;
+  return str;
 }
 
-bool
-HexagonDYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry)
-{
-    entry.clear();
-    entry.link_addr = addr;
-    
-    if (!(addr = ReadPointer(addr, &entry.base_addr)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.path_addr)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.dyn_addr)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.next)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.prev)))
-        return false;
-    
-    entry.path = ReadStringFromMemory(entry.path_addr);
-    
-    return true;
-}
+bool HexagonDYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr,
+                                                  SOEntry &entry) {
+  entry.clear();
+  entry.link_addr = addr;
+
+  if (!(addr = ReadPointer(addr, &entry.base_addr)))
+    return false;
 
-bool
-HexagonDYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
-{
-    Target& target = m_process->GetTarget();
+  if (!(addr = ReadPointer(addr, &entry.path_addr)))
+    return false;
 
-    SymbolContextList list;
-    if (!target.GetImages().FindSymbolsWithNameAndType (ConstString(name), eSymbolTypeAny, list))
-        return false;
+  if (!(addr = ReadPointer(addr, &entry.dyn_addr)))
+    return false;
 
-    Address address = list[0].symbol->GetAddress();
-    addr_t addr = address.GetLoadAddress (&target);
-    if (addr == LLDB_INVALID_ADDRESS)
-        return false;
+  if (!(addr = ReadPointer(addr, &entry.next)))
+    return false;
 
-    Error error;
-    value = (uint32_t)m_process->ReadUnsignedIntegerFromMemory(addr + field*sizeof(uint32_t), sizeof(uint32_t), 0, error);
-    if (error.Fail())
-        return false;
+  if (!(addr = ReadPointer(addr, &entry.prev)))
+    return false;
 
-    if (field == eSize)
-        value /= 8; // convert bits to bytes
+  entry.path = ReadStringFromMemory(entry.path_addr);
 
-    return true;
+  return true;
 }
 
-const HexagonDYLDRendezvous::ThreadInfo&
-HexagonDYLDRendezvous::GetThreadInfo()
-{
-    if (!m_thread_info.valid)
-    {
-        bool ok = true;
+bool HexagonDYLDRendezvous::FindMetadata(const char *name, PThreadField field,
+                                         uint32_t &value) {
+  Target &target = m_process->GetTarget();
 
-        ok &= FindMetadata ("_thread_db_pthread_dtvp", eOffset, m_thread_info.dtv_offset);
-        ok &= FindMetadata ("_thread_db_dtv_dtv", eSize, m_thread_info.dtv_slot_size);
-        ok &= FindMetadata ("_thread_db_link_map_l_tls_modid", eOffset, m_thread_info.modid_offset);
-        ok &= FindMetadata ("_thread_db_dtv_t_pointer_val", eOffset, m_thread_info.tls_offset);
+  SymbolContextList list;
+  if (!target.GetImages().FindSymbolsWithNameAndType(ConstString(name),
+                                                     eSymbolTypeAny, list))
+    return false;
 
-        if (ok)
-            m_thread_info.valid = true;
-    }
+  Address address = list[0].symbol->GetAddress();
+  addr_t addr = address.GetLoadAddress(&target);
+  if (addr == LLDB_INVALID_ADDRESS)
+    return false;
+
+  Error error;
+  value = (uint32_t)m_process->ReadUnsignedIntegerFromMemory(
+      addr + field * sizeof(uint32_t), sizeof(uint32_t), 0, error);
+  if (error.Fail())
+    return false;
 
-    return m_thread_info;
+  if (field == eSize)
+    value /= 8; // convert bits to bytes
+
+  return true;
 }
 
-void
-HexagonDYLDRendezvous::DumpToLog(Log *log) const
-{
-    int state = GetState();
-
-    if (!log)
-        return;
-
-    log->PutCString("HexagonDYLDRendezvous:");
-    log->Printf("   Address: %" PRIx64, GetRendezvousAddress());
-    log->Printf("   Version: %" PRIu64, GetVersion());
-    log->Printf("   Link   : %" PRIx64, GetLinkMapAddress());
-    log->Printf("   Break  : %" PRIx64, GetBreakAddress());
-    log->Printf("   LDBase : %" PRIx64, GetLDBase());
-    log->Printf("   State  : %s", 
-                (state == eConsistent) ? "consistent" :
-                (state == eAdd)        ? "add"        :
-                (state == eDelete)     ? "delete"     : "unknown");
-    
-    iterator I = begin();
-    iterator E = end();
-
-    if (I != E) 
-        log->PutCString("HexagonDYLDRendezvous SOEntries:");
-    
-    for (int i = 1; I != E; ++I, ++i) 
-    {
-        log->Printf("\n   SOEntry [%d] %s", i, I->path.c_str());
-        log->Printf("      Base : %" PRIx64, I->base_addr);
-        log->Printf("      Path : %" PRIx64, I->path_addr);
-        log->Printf("      Dyn  : %" PRIx64, I->dyn_addr);
-        log->Printf("      Next : %" PRIx64, I->next);
-        log->Printf("      Prev : %" PRIx64, I->prev);
-    }
+const HexagonDYLDRendezvous::ThreadInfo &
+HexagonDYLDRendezvous::GetThreadInfo() {
+  if (!m_thread_info.valid) {
+    bool ok = true;
+
+    ok &= FindMetadata("_thread_db_pthread_dtvp", eOffset,
+                       m_thread_info.dtv_offset);
+    ok &=
+        FindMetadata("_thread_db_dtv_dtv", eSize, m_thread_info.dtv_slot_size);
+    ok &= FindMetadata("_thread_db_link_map_l_tls_modid", eOffset,
+                       m_thread_info.modid_offset);
+    ok &= FindMetadata("_thread_db_dtv_t_pointer_val", eOffset,
+                       m_thread_info.tls_offset);
+
+    if (ok)
+      m_thread_info.valid = true;
+  }
+
+  return m_thread_info;
+}
+
+void HexagonDYLDRendezvous::DumpToLog(Log *log) const {
+  int state = GetState();
+
+  if (!log)
+    return;
+
+  log->PutCString("HexagonDYLDRendezvous:");
+  log->Printf("   Address: %" PRIx64, GetRendezvousAddress());
+  log->Printf("   Version: %" PRIu64, GetVersion());
+  log->Printf("   Link   : %" PRIx64, GetLinkMapAddress());
+  log->Printf("   Break  : %" PRIx64, GetBreakAddress());
+  log->Printf("   LDBase : %" PRIx64, GetLDBase());
+  log->Printf("   State  : %s",
+              (state == eConsistent)
+                  ? "consistent"
+                  : (state == eAdd) ? "add" : (state == eDelete) ? "delete"
+                                                                 : "unknown");
+
+  iterator I = begin();
+  iterator E = end();
+
+  if (I != E)
+    log->PutCString("HexagonDYLDRendezvous SOEntries:");
+
+  for (int i = 1; I != E; ++I, ++i) {
+    log->Printf("\n   SOEntry [%d] %s", i, I->path.c_str());
+    log->Printf("      Base : %" PRIx64, I->base_addr);
+    log->Printf("      Path : %" PRIx64, I->path_addr);
+    log->Printf("      Dyn  : %" PRIx64, I->dyn_addr);
+    log->Printf("      Next : %" PRIx64, I->next);
+    log->Printf("      Prev : %" PRIx64, I->prev);
+  }
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h
index cd51213..b68f89b 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h
@@ -19,9 +19,8 @@
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
-namespace lldb_private
-{
-    class Process;
+namespace lldb_private {
+class Process;
 }
 
 /// @class HexagonDYLDRendezvous
@@ -31,249 +30,218 @@ namespace lldb_private
 /// runtime liker each time a module is loaded or unloaded.  This class provides
 /// an interface to this structure and maintains a consistent snapshot of the
 /// currently loaded modules.
-class HexagonDYLDRendezvous
-{
-
-    // This structure is used to hold the contents of the debug rendezvous
-    // information (struct r_debug) as found in the inferiors memory.  Note that
-    // the layout of this struct is not binary compatible, it is simply large
-    // enough to hold the information on both 32 and 64 bit platforms.
-    struct Rendezvous {
-        uint64_t     version;
-        lldb::addr_t map_addr;
-        lldb::addr_t brk;
-        uint64_t     state;
-        lldb::addr_t ldbase;
-
-        Rendezvous()
-        : version (0)
-        , map_addr(LLDB_INVALID_ADDRESS)
-        , brk     (LLDB_INVALID_ADDRESS)
-        , state   (0)
-        , ldbase  (0) 
-        { }
-
-    };
+class HexagonDYLDRendezvous {
+
+  // This structure is used to hold the contents of the debug rendezvous
+  // information (struct r_debug) as found in the inferiors memory.  Note that
+  // the layout of this struct is not binary compatible, it is simply large
+  // enough to hold the information on both 32 and 64 bit platforms.
+  struct Rendezvous {
+    uint64_t version;
+    lldb::addr_t map_addr;
+    lldb::addr_t brk;
+    uint64_t state;
+    lldb::addr_t ldbase;
+
+    Rendezvous()
+        : version(0), map_addr(LLDB_INVALID_ADDRESS), brk(LLDB_INVALID_ADDRESS),
+          state(0), ldbase(0) {}
+  };
 
 public:
-    // Various metadata supplied by the inferior's threading library to describe
-    // the per-thread state.
-    struct ThreadInfo {
-        bool     valid;         // whether we read valid metadata
-        uint32_t dtv_offset;    // offset of DTV pointer within pthread
-        uint32_t dtv_slot_size; // size of one DTV slot
-        uint32_t modid_offset;  // offset of module ID within link_map
-        uint32_t tls_offset;    // offset of TLS pointer within DTV slot
-    };
-
-    HexagonDYLDRendezvous(lldb_private::Process *process);
-
-    /// Update the internal snapshot of runtime linker rendezvous and recompute
-    /// the currently loaded modules.
-    ///
-    /// This method should be called once one start up, then once each time the
-    /// runtime linker enters the function given by GetBreakAddress().
-    ///
-    /// @returns true on success and false on failure.
-    ///
-    /// @see GetBreakAddress().
-    bool 
-    Resolve();
-
-    /// @returns true if this rendezvous has been located in the inferiors
-    /// address space and false otherwise.
-    bool 
-    IsValid();
-
-    /// @returns the address of the rendezvous structure in the inferiors
-    /// address space.
-    lldb::addr_t
-    GetRendezvousAddress() const { return m_rendezvous_addr; }
-   
-    /// Provide the dyld structure address
-    void
-    SetRendezvousAddress( lldb::addr_t );
-
-    /// @returns the version of the rendezvous protocol being used.
-    uint64_t
-    GetVersion() const { return m_current.version; }
-
-    /// @returns address in the inferiors address space containing the linked
-    /// list of shared object descriptors.
-    lldb::addr_t 
-    GetLinkMapAddress() const { return m_current.map_addr; }
-
-    /// A breakpoint should be set at this address and Resolve called on each
-    /// hit.
-    ///
-    /// @returns the address of a function called by the runtime linker each
-    /// time a module is loaded/unloaded, or about to be loaded/unloaded.
-    ///
-    /// @see Resolve()
-    lldb::addr_t
-    GetBreakAddress() const { return m_current.brk; }
-
-    /// In hexagon it is possible that we can know the dyld breakpoint without
-    /// having to find it from the rendezvous structure
-    ///
-    void
-    SetBreakAddress( lldb::addr_t addr ) { m_current.brk = addr; }
-
-    /// Returns the current state of the rendezvous structure.
-    uint64_t
-    GetState() const { return m_current.state; }
-
-    /// @returns the base address of the runtime linker in the inferiors address
-    /// space.
-    lldb::addr_t
-    GetLDBase() const { return m_current.ldbase; }
-
-    /// @returns the thread layout metadata from the inferiors thread library.
-    const ThreadInfo&
-    GetThreadInfo();
-
-    /// @returns true if modules have been loaded into the inferior since the
-    /// last call to Resolve().
-    bool
-    ModulesDidLoad() const { return !m_added_soentries.empty(); }
-
-    /// @returns true if modules have been unloaded from the inferior since the
-    /// last call to Resolve().
-    bool
-    ModulesDidUnload() const { return !m_removed_soentries.empty(); }
-
-    void
-    DumpToLog(lldb_private::Log *log) const;
-
-    /// @brief Constants describing the state of the rendezvous.
-    ///
-    /// @see GetState().
-    enum RendezvousState
-    {
-        eConsistent	= 0,
-        eAdd		,
-        eDelete		,
-    };
-
-    /// @brief Structure representing the shared objects currently loaded into
-    /// the inferior process.
-    ///
-    /// This object is a rough analogue to the struct link_map object which
-    /// actually lives in the inferiors memory.
-    struct SOEntry {
-        lldb::addr_t link_addr; ///< Address of this link_map.
-        lldb::addr_t base_addr; ///< Base address of the loaded object.
-        lldb::addr_t path_addr; ///< String naming the shared object.
-        lldb::addr_t dyn_addr;  ///< Dynamic section of shared object.
-        lldb::addr_t next;      ///< Address of next so_entry.
-        lldb::addr_t prev;      ///< Address of previous so_entry.
-        std::string  path;      ///< File name of shared object.
-
-        SOEntry() { clear(); }
-
-        bool operator ==(const SOEntry &entry) {
-            return this->path == entry.path;
-        }
-
-        void clear() {
-            link_addr = 0;
-            base_addr = 0;
-            path_addr = 0;
-            dyn_addr  = 0;
-            next = 0;
-            prev = 0;
-            path.clear();
-        }
-    };
+  // Various metadata supplied by the inferior's threading library to describe
+  // the per-thread state.
+  struct ThreadInfo {
+    bool valid;             // whether we read valid metadata
+    uint32_t dtv_offset;    // offset of DTV pointer within pthread
+    uint32_t dtv_slot_size; // size of one DTV slot
+    uint32_t modid_offset;  // offset of module ID within link_map
+    uint32_t tls_offset;    // offset of TLS pointer within DTV slot
+  };
+
+  HexagonDYLDRendezvous(lldb_private::Process *process);
+
+  /// Update the internal snapshot of runtime linker rendezvous and recompute
+  /// the currently loaded modules.
+  ///
+  /// This method should be called once one start up, then once each time the
+  /// runtime linker enters the function given by GetBreakAddress().
+  ///
+  /// @returns true on success and false on failure.
+  ///
+  /// @see GetBreakAddress().
+  bool Resolve();
+
+  /// @returns true if this rendezvous has been located in the inferiors
+  /// address space and false otherwise.
+  bool IsValid();
+
+  /// @returns the address of the rendezvous structure in the inferiors
+  /// address space.
+  lldb::addr_t GetRendezvousAddress() const { return m_rendezvous_addr; }
+
+  /// Provide the dyld structure address
+  void SetRendezvousAddress(lldb::addr_t);
+
+  /// @returns the version of the rendezvous protocol being used.
+  uint64_t GetVersion() const { return m_current.version; }
+
+  /// @returns address in the inferiors address space containing the linked
+  /// list of shared object descriptors.
+  lldb::addr_t GetLinkMapAddress() const { return m_current.map_addr; }
+
+  /// A breakpoint should be set at this address and Resolve called on each
+  /// hit.
+  ///
+  /// @returns the address of a function called by the runtime linker each
+  /// time a module is loaded/unloaded, or about to be loaded/unloaded.
+  ///
+  /// @see Resolve()
+  lldb::addr_t GetBreakAddress() const { return m_current.brk; }
+
+  /// In hexagon it is possible that we can know the dyld breakpoint without
+  /// having to find it from the rendezvous structure
+  ///
+  void SetBreakAddress(lldb::addr_t addr) { m_current.brk = addr; }
+
+  /// Returns the current state of the rendezvous structure.
+  uint64_t GetState() const { return m_current.state; }
+
+  /// @returns the base address of the runtime linker in the inferiors address
+  /// space.
+  lldb::addr_t GetLDBase() const { return m_current.ldbase; }
+
+  /// @returns the thread layout metadata from the inferiors thread library.
+  const ThreadInfo &GetThreadInfo();
+
+  /// @returns true if modules have been loaded into the inferior since the
+  /// last call to Resolve().
+  bool ModulesDidLoad() const { return !m_added_soentries.empty(); }
+
+  /// @returns true if modules have been unloaded from the inferior since the
+  /// last call to Resolve().
+  bool ModulesDidUnload() const { return !m_removed_soentries.empty(); }
+
+  void DumpToLog(lldb_private::Log *log) const;
+
+  /// @brief Constants describing the state of the rendezvous.
+  ///
+  /// @see GetState().
+  enum RendezvousState {
+    eConsistent = 0,
+    eAdd,
+    eDelete,
+  };
+
+  /// @brief Structure representing the shared objects currently loaded into
+  /// the inferior process.
+  ///
+  /// This object is a rough analogue to the struct link_map object which
+  /// actually lives in the inferiors memory.
+  struct SOEntry {
+    lldb::addr_t link_addr; ///< Address of this link_map.
+    lldb::addr_t base_addr; ///< Base address of the loaded object.
+    lldb::addr_t path_addr; ///< String naming the shared object.
+    lldb::addr_t dyn_addr;  ///< Dynamic section of shared object.
+    lldb::addr_t next;      ///< Address of next so_entry.
+    lldb::addr_t prev;      ///< Address of previous so_entry.
+    std::string path;       ///< File name of shared object.
+
+    SOEntry() { clear(); }
+
+    bool operator==(const SOEntry &entry) { return this->path == entry.path; }
+
+    void clear() {
+      link_addr = 0;
+      base_addr = 0;
+      path_addr = 0;
+      dyn_addr = 0;
+      next = 0;
+      prev = 0;
+      path.clear();
+    }
+  };
 
 protected:
-    typedef std::list<SOEntry> SOEntryList;
+  typedef std::list<SOEntry> SOEntryList;
 
 public:
-    typedef SOEntryList::const_iterator iterator;
-
-    /// Iterators over all currently loaded modules.
-    iterator begin() const { return m_soentries.begin(); }
-    iterator end() const { return m_soentries.end(); }
-
-    /// Iterators over all modules loaded into the inferior since the last call
-    /// to Resolve().
-    iterator loaded_begin() const { return m_added_soentries.begin(); }
-    iterator loaded_end() const { return m_added_soentries.end(); }
-
-    /// Iterators over all modules unloaded from the inferior since the last
-    /// call to Resolve().
-    iterator unloaded_begin() const { return m_removed_soentries.begin(); }
-    iterator unloaded_end() const { return m_removed_soentries.end(); }
-    
+  typedef SOEntryList::const_iterator iterator;
+
+  /// Iterators over all currently loaded modules.
+  iterator begin() const { return m_soentries.begin(); }
+  iterator end() const { return m_soentries.end(); }
+
+  /// Iterators over all modules loaded into the inferior since the last call
+  /// to Resolve().
+  iterator loaded_begin() const { return m_added_soentries.begin(); }
+  iterator loaded_end() const { return m_added_soentries.end(); }
+
+  /// Iterators over all modules unloaded from the inferior since the last
+  /// call to Resolve().
+  iterator unloaded_begin() const { return m_removed_soentries.begin(); }
+  iterator unloaded_end() const { return m_removed_soentries.end(); }
+
 protected:
-    lldb_private::Process *m_process;
+  lldb_private::Process *m_process;
 
-    // Cached copy of executable pathname
-    char m_exe_path[PATH_MAX];
+  // Cached copy of executable pathname
+  char m_exe_path[PATH_MAX];
 
-    /// Location of the r_debug structure in the inferiors address space.
-    lldb::addr_t m_rendezvous_addr;
+  /// Location of the r_debug structure in the inferiors address space.
+  lldb::addr_t m_rendezvous_addr;
 
-    /// Current and previous snapshots of the rendezvous structure.
-    Rendezvous m_current;
-    Rendezvous m_previous;
+  /// Current and previous snapshots of the rendezvous structure.
+  Rendezvous m_current;
+  Rendezvous m_previous;
 
-    /// List of SOEntry objects corresponding to the current link map state.
-    SOEntryList m_soentries;
+  /// List of SOEntry objects corresponding to the current link map state.
+  SOEntryList m_soentries;
 
-    /// List of SOEntry's added to the link map since the last call to Resolve().
-    SOEntryList m_added_soentries;
+  /// List of SOEntry's added to the link map since the last call to Resolve().
+  SOEntryList m_added_soentries;
 
-    /// List of SOEntry's removed from the link map since the last call to
-    /// Resolve().
-    SOEntryList m_removed_soentries;
+  /// List of SOEntry's removed from the link map since the last call to
+  /// Resolve().
+  SOEntryList m_removed_soentries;
 
-    /// Threading metadata read from the inferior.
-    ThreadInfo  m_thread_info;
+  /// Threading metadata read from the inferior.
+  ThreadInfo m_thread_info;
 
-    /// Reads an unsigned integer of @p size bytes from the inferior's address
-    /// space starting at @p addr.
-    ///
-    /// @returns addr + size if the read was successful and false otherwise.
-    lldb::addr_t
-    ReadWord(lldb::addr_t addr, uint64_t *dst, size_t size);
+  /// Reads an unsigned integer of @p size bytes from the inferior's address
+  /// space starting at @p addr.
+  ///
+  /// @returns addr + size if the read was successful and false otherwise.
+  lldb::addr_t ReadWord(lldb::addr_t addr, uint64_t *dst, size_t size);
 
-    /// Reads an address from the inferior's address space starting at @p addr.
-    ///
-    /// @returns addr + target address size if the read was successful and
-    /// 0 otherwise.
-    lldb::addr_t
-    ReadPointer(lldb::addr_t addr, lldb::addr_t *dst);
+  /// Reads an address from the inferior's address space starting at @p addr.
+  ///
+  /// @returns addr + target address size if the read was successful and
+  /// 0 otherwise.
+  lldb::addr_t ReadPointer(lldb::addr_t addr, lldb::addr_t *dst);
 
-    /// Reads a null-terminated C string from the memory location starting at @p
-    /// addr.
-    std::string
-    ReadStringFromMemory(lldb::addr_t addr);
+  /// Reads a null-terminated C string from the memory location starting at @p
+  /// addr.
+  std::string ReadStringFromMemory(lldb::addr_t addr);
 
-    /// Reads an SOEntry starting at @p addr.
-    bool
-    ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry);
+  /// Reads an SOEntry starting at @p addr.
+  bool ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry);
 
-    /// Updates the current set of SOEntries, the set of added entries, and the
-    /// set of removed entries.
-    bool
-    UpdateSOEntries();
+  /// Updates the current set of SOEntries, the set of added entries, and the
+  /// set of removed entries.
+  bool UpdateSOEntries();
 
-    bool
-    UpdateSOEntriesForAddition();
+  bool UpdateSOEntriesForAddition();
 
-    bool
-    UpdateSOEntriesForDeletion();
+  bool UpdateSOEntriesForDeletion();
 
-    /// Reads the current list of shared objects according to the link map
-    /// supplied by the runtime linker.
-    bool
-    TakeSnapshot(SOEntryList &entry_list);
+  /// Reads the current list of shared objects according to the link map
+  /// supplied by the runtime linker.
+  bool TakeSnapshot(SOEntryList &entry_list);
 
-    enum PThreadField { eSize, eNElem, eOffset };
+  enum PThreadField { eSize, eNElem, eOffset };
 
-    bool FindMetadata(const char *name, PThreadField field, uint32_t& value);
+  bool FindMetadata(const char *name, PThreadField field, uint32_t &value);
 };
 
 #endif // liblldb_HexagonDYLDRendezvous_H_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp
index 04a6792..ec655c6 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp
@@ -28,113 +28,92 @@
 using namespace lldb;
 using namespace lldb_private;
 
-static bool
-GetMaxU64(DataExtractor &data,
-          lldb::offset_t *offset_ptr,
-          uint64_t *value,
-          unsigned int byte_size)
-{
-    lldb::offset_t saved_offset = *offset_ptr;
-    *value = data.GetMaxU64(offset_ptr, byte_size);
-    return *offset_ptr != saved_offset;
+static bool GetMaxU64(DataExtractor &data, lldb::offset_t *offset_ptr,
+                      uint64_t *value, unsigned int byte_size) {
+  lldb::offset_t saved_offset = *offset_ptr;
+  *value = data.GetMaxU64(offset_ptr, byte_size);
+  return *offset_ptr != saved_offset;
 }
 
-static bool
-ParseAuxvEntry(DataExtractor &data,
-               AuxVector::Entry &entry,
-               lldb::offset_t *offset_ptr,
-               unsigned int byte_size)
-{
-    if (!GetMaxU64(data, offset_ptr, &entry.type, byte_size))
-        return false;
+static bool ParseAuxvEntry(DataExtractor &data, AuxVector::Entry &entry,
+                           lldb::offset_t *offset_ptr, unsigned int byte_size) {
+  if (!GetMaxU64(data, offset_ptr, &entry.type, byte_size))
+    return false;
 
-    if (!GetMaxU64(data, offset_ptr, &entry.value, byte_size))
-        return false;
+  if (!GetMaxU64(data, offset_ptr, &entry.value, byte_size))
+    return false;
 
-    return true;
+  return true;
 }
 
-DataBufferSP
-AuxVector::GetAuxvData()
-{
-    if (m_process)
-        return m_process->GetAuxvData ();
-    else
-        return DataBufferSP ();
+DataBufferSP AuxVector::GetAuxvData() {
+  if (m_process)
+    return m_process->GetAuxvData();
+  else
+    return DataBufferSP();
 }
 
-void
-AuxVector::ParseAuxv(DataExtractor &data)
-{
-    const unsigned int byte_size  = m_process->GetAddressByteSize();
-    lldb::offset_t offset = 0;
+void AuxVector::ParseAuxv(DataExtractor &data) {
+  const unsigned int byte_size = m_process->GetAddressByteSize();
+  lldb::offset_t offset = 0;
 
-    for (;;) 
-    {
-        Entry entry;
+  for (;;) {
+    Entry entry;
 
-        if (!ParseAuxvEntry(data, entry, &offset, byte_size))
-            break;
+    if (!ParseAuxvEntry(data, entry, &offset, byte_size))
+      break;
 
-        if (entry.type == AT_NULL)
-            break;
+    if (entry.type == AT_NULL)
+      break;
 
-        if (entry.type == AT_IGNORE)
-            continue;
+    if (entry.type == AT_IGNORE)
+      continue;
 
-        m_auxv.push_back(entry);
-    }
+    m_auxv.push_back(entry);
+  }
 }
 
-AuxVector::AuxVector(Process *process)
-    : m_process(process)
-{
-    DataExtractor data;
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+AuxVector::AuxVector(Process *process) : m_process(process) {
+  DataExtractor data;
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+
+  data.SetData(GetAuxvData());
+  data.SetByteOrder(m_process->GetByteOrder());
+  data.SetAddressByteSize(m_process->GetAddressByteSize());
 
-    data.SetData(GetAuxvData());
-    data.SetByteOrder(m_process->GetByteOrder());
-    data.SetAddressByteSize(m_process->GetAddressByteSize());
-    
-    ParseAuxv(data);
+  ParseAuxv(data);
 
-    if (log)
-        DumpToLog(log);
+  if (log)
+    DumpToLog(log);
 }
 
-AuxVector::iterator 
-AuxVector::FindEntry(EntryType type) const
-{
-    for (iterator I = begin(); I != end(); ++I)
-    {
-        if (I->type == static_cast<uint64_t>(type))
-            return I;
-    }
+AuxVector::iterator AuxVector::FindEntry(EntryType type) const {
+  for (iterator I = begin(); I != end(); ++I) {
+    if (I->type == static_cast<uint64_t>(type))
+      return I;
+  }
 
-    return end();
+  return end();
 }
 
-void
-AuxVector::DumpToLog(Log *log) const
-{
-    if (!log)
-        return;
+void AuxVector::DumpToLog(Log *log) const {
+  if (!log)
+    return;
 
-    log->PutCString("AuxVector: ");
-    for (iterator I = begin(); I != end(); ++I)
-    {
-        log->Printf("   %s [%" PRIu64 "]: %" PRIx64, GetEntryName(*I), I->type, I->value);
-    }
+  log->PutCString("AuxVector: ");
+  for (iterator I = begin(); I != end(); ++I) {
+    log->Printf("   %s [%" PRIu64 "]: %" PRIx64, GetEntryName(*I), I->type,
+                I->value);
+  }
 }
 
-const char *
-AuxVector::GetEntryName(EntryType type)
-{
-    const char *name = "AT_???";
+const char *AuxVector::GetEntryName(EntryType type) {
+  const char *name = "AT_???";
 
-#define ENTRY_NAME(_type) _type: name = #_type
-    switch (type) 
-    {
+#define ENTRY_NAME(_type)                                                      \
+  _type:                                                                       \
+  name = #_type
+  switch (type) {
     case ENTRY_NAME(AT_NULL);           break;
     case ENTRY_NAME(AT_IGNORE);         break;
     case ENTRY_NAME(AT_EXECFD);         break;
@@ -173,4 +152,3 @@ AuxVector::GetEntryName(EntryType type)
 
     return name;
 }
-
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h
index 2d39edd..9c3e1b0 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h
@@ -19,7 +19,7 @@
 
 namespace lldb_private {
 class DataExtractor;
-} 
+}
 
 /// @class AuxVector
 /// @brief Represents a processes auxiliary vector.
@@ -31,85 +31,80 @@ class DataExtractor;
 class AuxVector {
 
 public:
-    AuxVector(lldb_private::Process *process);
-
-    struct Entry {
-        uint64_t type;
-        uint64_t value;
-
-        Entry() : type(0), value(0) { }
-    };
-
-    /// Constants describing the type of entry.
-    /// On Linux, running "LD_SHOW_AUXV=1 ./executable" will spew AUX information.
-    enum EntryType {
-        AT_NULL           = 0,   ///< End of auxv.
-        AT_IGNORE         = 1,   ///< Ignore entry.
-        AT_EXECFD         = 2,   ///< File descriptor of program.
-        AT_PHDR           = 3,   ///< Program headers.
-        AT_PHENT          = 4,   ///< Size of program header.
-        AT_PHNUM          = 5,   ///< Number of program headers.
-        AT_PAGESZ         = 6,   ///< Page size.
-        AT_BASE           = 7,   ///< Interpreter base address.
-        AT_FLAGS          = 8,   ///< Flags.
-        AT_ENTRY          = 9,   ///< Program entry point.
-        AT_NOTELF         = 10,  ///< Set if program is not an ELF.
-        AT_UID            = 11,  ///< UID.
-        AT_EUID           = 12,  ///< Effective UID.
-        AT_GID            = 13,  ///< GID.
-        AT_EGID           = 14,  ///< Effective GID.
-        AT_CLKTCK         = 17,  ///< Clock frequency (e.g. times(2)).
-        AT_PLATFORM       = 15,  ///< String identifying platform.
-        AT_HWCAP          = 16,  ///< Machine dependent hints about processor capabilities.
-        AT_FPUCW          = 18,  ///< Used FPU control word.
-        AT_DCACHEBSIZE    = 19,  ///< Data cache block size.
-        AT_ICACHEBSIZE    = 20,  ///< Instruction cache block size.
-        AT_UCACHEBSIZE    = 21,  ///< Unified cache block size.
-        AT_IGNOREPPC      = 22,  ///< Entry should be ignored.
-        AT_SECURE         = 23,  ///< Boolean, was exec setuid-like?
-        AT_BASE_PLATFORM  = 24,  ///< String identifying real platforms.
-        AT_RANDOM         = 25,  ///< Address of 16 random bytes.
-        AT_EXECFN         = 31,  ///< Filename of executable.
-        AT_SYSINFO        = 32,  ///< Pointer to the global system page used for system calls and other nice things.
-        AT_SYSINFO_EHDR   = 33,  
-        AT_L1I_CACHESHAPE = 34,  ///< Shapes of the caches.
-        AT_L1D_CACHESHAPE = 35,
-        AT_L2_CACHESHAPE  = 36,
-        AT_L3_CACHESHAPE  = 37,
-    };
+  AuxVector(lldb_private::Process *process);
+
+  struct Entry {
+    uint64_t type;
+    uint64_t value;
+
+    Entry() : type(0), value(0) {}
+  };
+
+  /// Constants describing the type of entry.
+  /// On Linux, running "LD_SHOW_AUXV=1 ./executable" will spew AUX information.
+  enum EntryType {
+    AT_NULL = 0,      ///< End of auxv.
+    AT_IGNORE = 1,    ///< Ignore entry.
+    AT_EXECFD = 2,    ///< File descriptor of program.
+    AT_PHDR = 3,      ///< Program headers.
+    AT_PHENT = 4,     ///< Size of program header.
+    AT_PHNUM = 5,     ///< Number of program headers.
+    AT_PAGESZ = 6,    ///< Page size.
+    AT_BASE = 7,      ///< Interpreter base address.
+    AT_FLAGS = 8,     ///< Flags.
+    AT_ENTRY = 9,     ///< Program entry point.
+    AT_NOTELF = 10,   ///< Set if program is not an ELF.
+    AT_UID = 11,      ///< UID.
+    AT_EUID = 12,     ///< Effective UID.
+    AT_GID = 13,      ///< GID.
+    AT_EGID = 14,     ///< Effective GID.
+    AT_CLKTCK = 17,   ///< Clock frequency (e.g. times(2)).
+    AT_PLATFORM = 15, ///< String identifying platform.
+    AT_HWCAP = 16,    ///< Machine dependent hints about processor capabilities.
+    AT_FPUCW = 18,    ///< Used FPU control word.
+    AT_DCACHEBSIZE = 19,   ///< Data cache block size.
+    AT_ICACHEBSIZE = 20,   ///< Instruction cache block size.
+    AT_UCACHEBSIZE = 21,   ///< Unified cache block size.
+    AT_IGNOREPPC = 22,     ///< Entry should be ignored.
+    AT_SECURE = 23,        ///< Boolean, was exec setuid-like?
+    AT_BASE_PLATFORM = 24, ///< String identifying real platforms.
+    AT_RANDOM = 25,        ///< Address of 16 random bytes.
+    AT_EXECFN = 31,        ///< Filename of executable.
+    AT_SYSINFO = 32, ///< Pointer to the global system page used for system
+                     ///calls and other nice things.
+    AT_SYSINFO_EHDR = 33,
+    AT_L1I_CACHESHAPE = 34, ///< Shapes of the caches.
+    AT_L1D_CACHESHAPE = 35,
+    AT_L2_CACHESHAPE = 36,
+    AT_L3_CACHESHAPE = 37,
+  };
 
 private:
-    typedef std::vector<Entry> EntryVector;
+  typedef std::vector<Entry> EntryVector;
 
 public:
-    typedef EntryVector::const_iterator iterator;
+  typedef EntryVector::const_iterator iterator;
 
-    iterator begin() const { return m_auxv.begin(); }
-    iterator end() const { return m_auxv.end(); }
+  iterator begin() const { return m_auxv.begin(); }
+  iterator end() const { return m_auxv.end(); }
 
-    iterator 
-    FindEntry(EntryType type) const;
+  iterator FindEntry(EntryType type) const;
 
-    static const char *
-    GetEntryName(const Entry &entry) { 
-        return GetEntryName(static_cast<EntryType>(entry.type)); 
-    }
+  static const char *GetEntryName(const Entry &entry) {
+    return GetEntryName(static_cast<EntryType>(entry.type));
+  }
 
-    static const char *
-    GetEntryName(EntryType type);
+  static const char *GetEntryName(EntryType type);
 
-    void
-    DumpToLog(lldb_private::Log *log) const;
+  void DumpToLog(lldb_private::Log *log) const;
 
 private:
-    lldb_private::Process *m_process;
-    EntryVector m_auxv;
+  lldb_private::Process *m_process;
+  EntryVector m_auxv;
 
-    lldb::DataBufferSP
-    GetAuxvData();
+  lldb::DataBufferSP GetAuxvData();
 
-    void
-    ParseAuxv(lldb_private::DataExtractor &data);
+  void ParseAuxv(lldb_private::DataExtractor &data);
 };
 
 #endif
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
index 443f97e..136bf65 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
@@ -30,631 +30,582 @@ using namespace lldb_private;
 
 /// Locates the address of the rendezvous structure.  Returns the address on
 /// success and LLDB_INVALID_ADDRESS on failure.
-static addr_t
-ResolveRendezvousAddress(Process *process)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    addr_t info_location;
-    addr_t info_addr;
-    Error error;
-
-    if (!process)
-    {
-        if (log)
-            log->Printf ("%s null process provided", __FUNCTION__);
-        return LLDB_INVALID_ADDRESS;
-    }
+static addr_t ResolveRendezvousAddress(Process *process) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  addr_t info_location;
+  addr_t info_addr;
+  Error error;
 
-    // Try to get it from our process.  This might be a remote process and might
-    // grab it via some remote-specific mechanism.
-    info_location = process->GetImageInfoAddress();
+  if (!process) {
     if (log)
-        log->Printf ("%s info_location = 0x%" PRIx64, __FUNCTION__, info_location);
-
-    // If the process fails to return an address, fall back to seeing if the local object file can help us find it.
-    if (info_location == LLDB_INVALID_ADDRESS)
-    {
-        Target *target = &process->GetTarget();
-        if (target)
-        {
-            ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
-            Address addr = obj_file->GetImageInfoAddress(target);
-
-            if (addr.IsValid())
-            {
-                info_location = addr.GetLoadAddress(target);
-                if (log)
-                    log->Printf ("%s resolved via direct object file approach to 0x%" PRIx64, __FUNCTION__, info_location);
-            }
-            else
-            {
-                if (log)
-                    log->Printf ("%s FAILED - direct object file approach did not yield a valid address", __FUNCTION__);
-            }
-        }
-    }
-
-    if (info_location == LLDB_INVALID_ADDRESS)
-    {
+      log->Printf("%s null process provided", __FUNCTION__);
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  // Try to get it from our process.  This might be a remote process and might
+  // grab it via some remote-specific mechanism.
+  info_location = process->GetImageInfoAddress();
+  if (log)
+    log->Printf("%s info_location = 0x%" PRIx64, __FUNCTION__, info_location);
+
+  // If the process fails to return an address, fall back to seeing if the local
+  // object file can help us find it.
+  if (info_location == LLDB_INVALID_ADDRESS) {
+    Target *target = &process->GetTarget();
+    if (target) {
+      ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
+      Address addr = obj_file->GetImageInfoAddress(target);
+
+      if (addr.IsValid()) {
+        info_location = addr.GetLoadAddress(target);
         if (log)
-            log->Printf ("%s FAILED - invalid info address", __FUNCTION__);
-        return LLDB_INVALID_ADDRESS;
+          log->Printf(
+              "%s resolved via direct object file approach to 0x%" PRIx64,
+              __FUNCTION__, info_location);
+      } else {
+        if (log)
+          log->Printf("%s FAILED - direct object file approach did not yield a "
+                      "valid address",
+                      __FUNCTION__);
+      }
     }
+  }
 
+  if (info_location == LLDB_INVALID_ADDRESS) {
     if (log)
-        log->Printf ("%s reading pointer (%" PRIu32 " bytes) from 0x%" PRIx64, __FUNCTION__, process->GetAddressByteSize(), info_location);
+      log->Printf("%s FAILED - invalid info address", __FUNCTION__);
+    return LLDB_INVALID_ADDRESS;
+  }
 
-    info_addr = process->ReadPointerFromMemory(info_location, error);
-    if (error.Fail())
-    {
-        if (log)
-            log->Printf ("%s FAILED - could not read from the info location: %s", __FUNCTION__, error.AsCString ());
-        return LLDB_INVALID_ADDRESS;
-    }
+  if (log)
+    log->Printf("%s reading pointer (%" PRIu32 " bytes) from 0x%" PRIx64,
+                __FUNCTION__, process->GetAddressByteSize(), info_location);
 
-    if (info_addr == 0)
-    {
-        if (log)
-            log->Printf ("%s FAILED - the rendezvous address contained at 0x%" PRIx64 " returned a null value", __FUNCTION__, info_location);
-        return LLDB_INVALID_ADDRESS;
-    }
+  info_addr = process->ReadPointerFromMemory(info_location, error);
+  if (error.Fail()) {
+    if (log)
+      log->Printf("%s FAILED - could not read from the info location: %s",
+                  __FUNCTION__, error.AsCString());
+    return LLDB_INVALID_ADDRESS;
+  }
 
-    return info_addr;
+  if (info_addr == 0) {
+    if (log)
+      log->Printf("%s FAILED - the rendezvous address contained at 0x%" PRIx64
+                  " returned a null value",
+                  __FUNCTION__, info_location);
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  return info_addr;
 }
 
 DYLDRendezvous::DYLDRendezvous(Process *process)
-    : m_process(process),
-      m_rendezvous_addr(LLDB_INVALID_ADDRESS),
-      m_current(),
-      m_previous(),
-      m_loaded_modules(),
-      m_soentries(),
-      m_added_soentries(),
-      m_removed_soentries()
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-
-    m_thread_info.valid = false;
-
-    // Cache a copy of the executable path
-    if (m_process)
-    {
-        Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
-        if (exe_mod)
-        {
-            m_exe_file_spec = exe_mod->GetPlatformFileSpec();
-            if (log)
-                log->Printf ("DYLDRendezvous::%s exe module executable path set: '%s'",
-                        __FUNCTION__, m_exe_file_spec.GetCString());
-        }
-        else
-        {
-            if (log)
-                log->Printf ("DYLDRendezvous::%s cannot cache exe module path: null executable module pointer", __FUNCTION__);
-        }
+    : m_process(process), m_rendezvous_addr(LLDB_INVALID_ADDRESS), m_current(),
+      m_previous(), m_loaded_modules(), m_soentries(), m_added_soentries(),
+      m_removed_soentries() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+
+  m_thread_info.valid = false;
+
+  // Cache a copy of the executable path
+  if (m_process) {
+    Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
+    if (exe_mod) {
+      m_exe_file_spec = exe_mod->GetPlatformFileSpec();
+      if (log)
+        log->Printf("DYLDRendezvous::%s exe module executable path set: '%s'",
+                    __FUNCTION__, m_exe_file_spec.GetCString());
+    } else {
+      if (log)
+        log->Printf("DYLDRendezvous::%s cannot cache exe module path: null "
+                    "executable module pointer",
+                    __FUNCTION__);
     }
+  }
 }
 
-bool
-DYLDRendezvous::Resolve()
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+bool DYLDRendezvous::Resolve() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+
+  const size_t word_size = 4;
+  Rendezvous info;
+  size_t address_size;
+  size_t padding;
+  addr_t info_addr;
+  addr_t cursor;
+
+  address_size = m_process->GetAddressByteSize();
+  padding = address_size - word_size;
+  if (log)
+    log->Printf("DYLDRendezvous::%s address size: %" PRIu64
+                ", padding %" PRIu64,
+                __FUNCTION__, uint64_t(address_size), uint64_t(padding));
+
+  if (m_rendezvous_addr == LLDB_INVALID_ADDRESS)
+    cursor = info_addr = ResolveRendezvousAddress(m_process);
+  else
+    cursor = info_addr = m_rendezvous_addr;
+  if (log)
+    log->Printf("DYLDRendezvous::%s cursor = 0x%" PRIx64, __FUNCTION__, cursor);
+
+  if (cursor == LLDB_INVALID_ADDRESS)
+    return false;
 
-    const size_t word_size = 4;
-    Rendezvous info;
-    size_t address_size;
-    size_t padding;
-    addr_t info_addr;
-    addr_t cursor;
+  if (!(cursor = ReadWord(cursor, &info.version, word_size)))
+    return false;
 
-    address_size = m_process->GetAddressByteSize();
-    padding = address_size - word_size;
-    if (log)
-        log->Printf ("DYLDRendezvous::%s address size: %" PRIu64 ", padding %" PRIu64, __FUNCTION__, uint64_t(address_size), uint64_t(padding));
+  if (!(cursor = ReadPointer(cursor + padding, &info.map_addr)))
+    return false;
 
-    if (m_rendezvous_addr == LLDB_INVALID_ADDRESS)
-        cursor = info_addr = ResolveRendezvousAddress(m_process);
-    else
-        cursor = info_addr = m_rendezvous_addr;
-    if (log)
-        log->Printf ("DYLDRendezvous::%s cursor = 0x%" PRIx64, __FUNCTION__, cursor);
+  if (!(cursor = ReadPointer(cursor, &info.brk)))
+    return false;
 
-    if (cursor == LLDB_INVALID_ADDRESS)
-        return false;
+  if (!(cursor = ReadWord(cursor, &info.state, word_size)))
+    return false;
 
-    if (!(cursor = ReadWord(cursor, &info.version, word_size)))
-        return false;
+  if (!(cursor = ReadPointer(cursor + padding, &info.ldbase)))
+    return false;
 
-    if (!(cursor = ReadPointer(cursor + padding, &info.map_addr)))
-        return false;
+  // The rendezvous was successfully read.  Update our internal state.
+  m_rendezvous_addr = info_addr;
+  m_previous = m_current;
+  m_current = info;
 
-    if (!(cursor = ReadPointer(cursor, &info.brk)))
-        return false;
+  if (UpdateSOEntries(true))
+    return true;
 
-    if (!(cursor = ReadWord(cursor, &info.state, word_size)))
-        return false;
+  return UpdateSOEntries();
+}
 
-    if (!(cursor = ReadPointer(cursor + padding, &info.ldbase)))
-        return false;
+bool DYLDRendezvous::IsValid() {
+  return m_rendezvous_addr != LLDB_INVALID_ADDRESS;
+}
 
-    // The rendezvous was successfully read.  Update our internal state.
-    m_rendezvous_addr = info_addr;
-    m_previous = m_current;
-    m_current = info;
+bool DYLDRendezvous::UpdateSOEntries(bool fromRemote) {
+  SOEntry entry;
+  LoadedModuleInfoList module_list;
 
-   if (UpdateSOEntries (true))
-       return true;
+  // If we can't get the SO info from the remote, return failure.
+  if (fromRemote && m_process->LoadModules(module_list) == 0)
+    return false;
 
-    return UpdateSOEntries();
-}
+  if (!fromRemote && m_current.map_addr == 0)
+    return false;
 
-bool
-DYLDRendezvous::IsValid()
-{
-    return m_rendezvous_addr != LLDB_INVALID_ADDRESS;
+  // When the previous and current states are consistent this is the first
+  // time we have been asked to update.  Just take a snapshot of the currently
+  // loaded modules.
+  if (m_previous.state == eConsistent && m_current.state == eConsistent)
+    return fromRemote ? SaveSOEntriesFromRemote(module_list)
+                      : TakeSnapshot(m_soentries);
+
+  // If we are about to add or remove a shared object clear out the current
+  // state and take a snapshot of the currently loaded images.
+  if (m_current.state == eAdd || m_current.state == eDelete) {
+    // Some versions of the android dynamic linker might send two
+    // notifications with state == eAdd back to back. Ignore them
+    // until we get an eConsistent notification.
+    if (!(m_previous.state == eConsistent ||
+          (m_previous.state == eAdd && m_current.state == eDelete)))
+      return false;
+
+    m_soentries.clear();
+    if (fromRemote)
+      return SaveSOEntriesFromRemote(module_list);
+
+    m_added_soentries.clear();
+    m_removed_soentries.clear();
+    return TakeSnapshot(m_soentries);
+  }
+  assert(m_current.state == eConsistent);
+
+  // Otherwise check the previous state to determine what to expect and update
+  // accordingly.
+  if (m_previous.state == eAdd)
+    return fromRemote ? AddSOEntriesFromRemote(module_list) : AddSOEntries();
+  else if (m_previous.state == eDelete)
+    return fromRemote ? RemoveSOEntriesFromRemote(module_list)
+                      : RemoveSOEntries();
+
+  return false;
 }
 
-bool
-DYLDRendezvous::UpdateSOEntries(bool fromRemote)
-{
-    SOEntry entry;
-    LoadedModuleInfoList module_list;
+bool DYLDRendezvous::FillSOEntryFromModuleInfo(
+    LoadedModuleInfoList::LoadedModuleInfo const &modInfo, SOEntry &entry) {
+  addr_t link_map_addr;
+  addr_t base_addr;
+  addr_t dyn_addr;
+  std::string name;
 
-    // If we can't get the SO info from the remote, return failure.
-    if (fromRemote && m_process->LoadModules (module_list) == 0)
-        return false;
+  if (!modInfo.get_link_map(link_map_addr) || !modInfo.get_base(base_addr) ||
+      !modInfo.get_dynamic(dyn_addr) || !modInfo.get_name(name))
+    return false;
 
-    if (!fromRemote && m_current.map_addr == 0)
-        return false;
+  entry.link_addr = link_map_addr;
+  entry.base_addr = base_addr;
+  entry.dyn_addr = dyn_addr;
 
-    // When the previous and current states are consistent this is the first
-    // time we have been asked to update.  Just take a snapshot of the currently
-    // loaded modules.
-    if (m_previous.state == eConsistent && m_current.state == eConsistent)
-        return fromRemote ? SaveSOEntriesFromRemote(module_list) : TakeSnapshot(m_soentries);
-
-    // If we are about to add or remove a shared object clear out the current
-    // state and take a snapshot of the currently loaded images.
-    if (m_current.state == eAdd || m_current.state == eDelete)
-    {
-        // Some versions of the android dynamic linker might send two
-        // notifications with state == eAdd back to back. Ignore them
-        // until we get an eConsistent notification.
-        if (!(m_previous.state == eConsistent || (m_previous.state == eAdd && m_current.state == eDelete)))
-            return false;
-
-        m_soentries.clear();
-        if (fromRemote)
-            return SaveSOEntriesFromRemote(module_list);
-
-        m_added_soentries.clear();
-        m_removed_soentries.clear();
-        return TakeSnapshot(m_soentries);
-    }
-    assert(m_current.state == eConsistent);
+  entry.file_spec.SetFile(name, false);
 
-    // Otherwise check the previous state to determine what to expect and update
-    // accordingly.
-    if (m_previous.state == eAdd)
-        return fromRemote ? AddSOEntriesFromRemote(module_list) : AddSOEntries();
-    else if (m_previous.state == eDelete)
-        return fromRemote ? RemoveSOEntriesFromRemote(module_list) : RemoveSOEntries();
+  UpdateBaseAddrIfNecessary(entry, name);
 
-    return false;
+  // not needed if we're using ModuleInfos
+  entry.next = 0;
+  entry.prev = 0;
+  entry.path_addr = 0;
+
+  return true;
 }
 
-bool
-DYLDRendezvous::FillSOEntryFromModuleInfo (LoadedModuleInfoList::LoadedModuleInfo const & modInfo,
-                                           SOEntry &entry)
-{
-    addr_t link_map_addr;
-    addr_t base_addr;
-    addr_t dyn_addr;
-    std::string name;
-
-    if (!modInfo.get_link_map (link_map_addr) ||
-        !modInfo.get_base (base_addr) ||
-        !modInfo.get_dynamic (dyn_addr) ||
-        !modInfo.get_name (name))
-        return false;
+bool DYLDRendezvous::SaveSOEntriesFromRemote(
+    LoadedModuleInfoList &module_list) {
+  for (auto const &modInfo : module_list.m_list) {
+    SOEntry entry;
+    if (!FillSOEntryFromModuleInfo(modInfo, entry))
+      return false;
 
-    entry.link_addr = link_map_addr;
-    entry.base_addr = base_addr;
-    entry.dyn_addr = dyn_addr;
+    // Only add shared libraries and not the executable.
+    if (!SOEntryIsMainExecutable(entry))
+      m_soentries.push_back(entry);
+  }
 
-    entry.file_spec.SetFile(name, false);
+  m_loaded_modules = module_list;
+  return true;
+}
 
-    UpdateBaseAddrIfNecessary(entry, name);
+bool DYLDRendezvous::AddSOEntriesFromRemote(LoadedModuleInfoList &module_list) {
+  for (auto const &modInfo : module_list.m_list) {
+    bool found = false;
+    for (auto const &existing : m_loaded_modules.m_list) {
+      if (modInfo == existing) {
+        found = true;
+        break;
+      }
+    }
 
-    // not needed if we're using ModuleInfos
-    entry.next = 0;
-    entry.prev = 0;
-    entry.path_addr = 0;
+    if (found)
+      continue;
 
-    return true;
+    SOEntry entry;
+    if (!FillSOEntryFromModuleInfo(modInfo, entry))
+      return false;
+
+    // Only add shared libraries and not the executable.
+    if (!SOEntryIsMainExecutable(entry))
+      m_soentries.push_back(entry);
+  }
+
+  m_loaded_modules = module_list;
+  return true;
 }
 
-bool
-DYLDRendezvous::SaveSOEntriesFromRemote(LoadedModuleInfoList &module_list)
-{
-    for (auto const & modInfo : module_list.m_list)
-    {
-        SOEntry entry;
-        if (!FillSOEntryFromModuleInfo(modInfo, entry))
-            return false;
-
-        // Only add shared libraries and not the executable.
-        if (!SOEntryIsMainExecutable(entry))
-            m_soentries.push_back(entry);
+bool DYLDRendezvous::RemoveSOEntriesFromRemote(
+    LoadedModuleInfoList &module_list) {
+  for (auto const &existing : m_loaded_modules.m_list) {
+    bool found = false;
+    for (auto const &modInfo : module_list.m_list) {
+      if (modInfo == existing) {
+        found = true;
+        break;
+      }
     }
 
-    m_loaded_modules = module_list;
-    return true;
+    if (found)
+      continue;
 
-}
+    SOEntry entry;
+    if (!FillSOEntryFromModuleInfo(existing, entry))
+      return false;
+
+    // Only add shared libraries and not the executable.
+    if (!SOEntryIsMainExecutable(entry)) {
+      auto pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
+      if (pos == m_soentries.end())
+        return false;
 
-bool
-DYLDRendezvous::AddSOEntriesFromRemote(LoadedModuleInfoList &module_list)
-{
-    for (auto const & modInfo : module_list.m_list)
-    {
-        bool found = false;
-        for (auto const & existing : m_loaded_modules.m_list)
-        {
-            if (modInfo == existing)
-            {
-                found = true;
-                break;
-            }
-        }
-
-        if (found)
-            continue;
-
-        SOEntry entry;
-        if (!FillSOEntryFromModuleInfo(modInfo, entry))
-            return false;
-
-        // Only add shared libraries and not the executable.
-        if (!SOEntryIsMainExecutable(entry))
-            m_soentries.push_back(entry);
+      m_soentries.erase(pos);
     }
+  }
 
-    m_loaded_modules = module_list;
-    return true;
+  m_loaded_modules = module_list;
+  return true;
 }
 
-bool
-DYLDRendezvous::RemoveSOEntriesFromRemote(LoadedModuleInfoList &module_list)
-{
-    for (auto const & existing : m_loaded_modules.m_list)
-    {
-        bool found = false;
-        for (auto const & modInfo : module_list.m_list)
-        {
-            if (modInfo == existing)
-            {
-                found = true;
-                break;
-            }
-        }
-
-        if (found)
-            continue;
-
-        SOEntry entry;
-        if (!FillSOEntryFromModuleInfo(existing, entry))
-            return false;
-
-        // Only add shared libraries and not the executable.
-        if (!SOEntryIsMainExecutable(entry))
-        {
-            auto pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
-            if (pos == m_soentries.end())
-                return false;
-
-            m_soentries.erase(pos);
-        }
-    }
+bool DYLDRendezvous::AddSOEntries() {
+  SOEntry entry;
+  iterator pos;
 
-    m_loaded_modules = module_list;
-    return true;
-}
+  assert(m_previous.state == eAdd);
 
-bool
-DYLDRendezvous::AddSOEntries()
-{
-    SOEntry entry;
-    iterator pos;
+  if (m_current.map_addr == 0)
+    return false;
 
-    assert(m_previous.state == eAdd);
+  for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next) {
+    if (!ReadSOEntryFromMemory(cursor, entry))
+      return false;
 
-    if (m_current.map_addr == 0)
-        return false;
+    // Only add shared libraries and not the executable.
+    if (SOEntryIsMainExecutable(entry))
+      continue;
 
-    for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
-    {
-        if (!ReadSOEntryFromMemory(cursor, entry))
-            return false;
-
-        // Only add shared libraries and not the executable.
-        if (SOEntryIsMainExecutable(entry))
-            continue;
-
-        pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
-        if (pos == m_soentries.end())
-        {
-            m_soentries.push_back(entry);
-            m_added_soentries.push_back(entry);
-        }
+    pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
+    if (pos == m_soentries.end()) {
+      m_soentries.push_back(entry);
+      m_added_soentries.push_back(entry);
     }
+  }
 
-    return true;
+  return true;
 }
 
-bool
-DYLDRendezvous::RemoveSOEntries()
-{
-    SOEntryList entry_list;
-    iterator pos;
+bool DYLDRendezvous::RemoveSOEntries() {
+  SOEntryList entry_list;
+  iterator pos;
 
-    assert(m_previous.state == eDelete);
+  assert(m_previous.state == eDelete);
 
-    if (!TakeSnapshot(entry_list))
-        return false;
+  if (!TakeSnapshot(entry_list))
+    return false;
 
-    for (iterator I = begin(); I != end(); ++I)
-    {
-        pos = std::find(entry_list.begin(), entry_list.end(), *I);
-        if (pos == entry_list.end())
-            m_removed_soentries.push_back(*I);
-    }
+  for (iterator I = begin(); I != end(); ++I) {
+    pos = std::find(entry_list.begin(), entry_list.end(), *I);
+    if (pos == entry_list.end())
+      m_removed_soentries.push_back(*I);
+  }
 
-    m_soentries = entry_list;
-    return true;
+  m_soentries = entry_list;
+  return true;
 }
 
-bool
-DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry)
-{
-    // On Linux the executable is indicated by an empty path in the entry. On
-    // FreeBSD and on Android it is the full path to the executable.
-
-    auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
-    switch (triple.getOS())
-    {
-        case llvm::Triple::FreeBSD:
-            return entry.file_spec == m_exe_file_spec;
-        case llvm::Triple::Linux:
-            if (triple.isAndroid())
-                return entry.file_spec == m_exe_file_spec;
-            return !entry.file_spec;
-        default:
-            return false;
-    }
+bool DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry) {
+  // On Linux the executable is indicated by an empty path in the entry. On
+  // FreeBSD and on Android it is the full path to the executable.
+
+  auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
+  switch (triple.getOS()) {
+  case llvm::Triple::FreeBSD:
+    return entry.file_spec == m_exe_file_spec;
+  case llvm::Triple::Linux:
+    if (triple.isAndroid())
+      return entry.file_spec == m_exe_file_spec;
+    return !entry.file_spec;
+  default:
+    return false;
+  }
 }
 
-bool
-DYLDRendezvous::TakeSnapshot(SOEntryList &entry_list)
-{
-    SOEntry entry;
+bool DYLDRendezvous::TakeSnapshot(SOEntryList &entry_list) {
+  SOEntry entry;
 
-    if (m_current.map_addr == 0)
-        return false;
+  if (m_current.map_addr == 0)
+    return false;
 
-    // Clear previous entries since we are about to obtain an up to date list.
-    entry_list.clear();
+  // Clear previous entries since we are about to obtain an up to date list.
+  entry_list.clear();
 
-    for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
-    {
-        if (!ReadSOEntryFromMemory(cursor, entry))
-            return false;
+  for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next) {
+    if (!ReadSOEntryFromMemory(cursor, entry))
+      return false;
 
-        // Only add shared libraries and not the executable.
-        if (SOEntryIsMainExecutable(entry))
-            continue;
+    // Only add shared libraries and not the executable.
+    if (SOEntryIsMainExecutable(entry))
+      continue;
 
-        entry_list.push_back(entry);
-    }
+    entry_list.push_back(entry);
+  }
 
-    return true;
+  return true;
 }
 
-addr_t
-DYLDRendezvous::ReadWord(addr_t addr, uint64_t *dst, size_t size)
-{
-    Error error;
+addr_t DYLDRendezvous::ReadWord(addr_t addr, uint64_t *dst, size_t size) {
+  Error error;
 
-    *dst = m_process->ReadUnsignedIntegerFromMemory(addr, size, 0, error);
-    if (error.Fail())
-        return 0;
+  *dst = m_process->ReadUnsignedIntegerFromMemory(addr, size, 0, error);
+  if (error.Fail())
+    return 0;
 
-    return addr + size;
+  return addr + size;
 }
 
-addr_t
-DYLDRendezvous::ReadPointer(addr_t addr, addr_t *dst)
-{
-    Error error;
- 
-    *dst = m_process->ReadPointerFromMemory(addr, error);
-    if (error.Fail())
-        return 0;
+addr_t DYLDRendezvous::ReadPointer(addr_t addr, addr_t *dst) {
+  Error error;
 
-    return addr + m_process->GetAddressByteSize();
+  *dst = m_process->ReadPointerFromMemory(addr, error);
+  if (error.Fail())
+    return 0;
+
+  return addr + m_process->GetAddressByteSize();
 }
 
-std::string
-DYLDRendezvous::ReadStringFromMemory(addr_t addr)
-{
-    std::string str;
-    Error error;
+std::string DYLDRendezvous::ReadStringFromMemory(addr_t addr) {
+  std::string str;
+  Error error;
 
-    if (addr == LLDB_INVALID_ADDRESS)
-        return std::string();
+  if (addr == LLDB_INVALID_ADDRESS)
+    return std::string();
 
-    m_process->ReadCStringFromMemory(addr, str, error);
+  m_process->ReadCStringFromMemory(addr, str, error);
 
-    return str;
+  return str;
 }
 
-// Returns true if the load bias reported by the linker is incorrect for the given entry. This
-// function is used to handle cases where we want to work around a bug in the system linker.
-static bool
-isLoadBiasIncorrect(Target& target, const std::string& file_path)
-{
-    // On Android L (API 21, 22) the load address of the "/system/bin/linker" isn't filled in
-    // correctly.
-    uint32_t os_major = 0, os_minor = 0, os_update = 0;
-    if (target.GetArchitecture().GetTriple().isAndroid() &&
-        target.GetPlatform()->GetOSVersion(os_major, os_minor, os_update) &&
-        (os_major == 21 || os_major == 22) &&
-        (file_path == "/system/bin/linker" || file_path == "/system/bin/linker64"))
-    {
-        return true;
-    }
+// Returns true if the load bias reported by the linker is incorrect for the
+// given entry. This
+// function is used to handle cases where we want to work around a bug in the
+// system linker.
+static bool isLoadBiasIncorrect(Target &target, const std::string &file_path) {
+  // On Android L (API 21, 22) the load address of the "/system/bin/linker"
+  // isn't filled in
+  // correctly.
+  uint32_t os_major = 0, os_minor = 0, os_update = 0;
+  if (target.GetArchitecture().GetTriple().isAndroid() &&
+      target.GetPlatform()->GetOSVersion(os_major, os_minor, os_update) &&
+      (os_major == 21 || os_major == 22) &&
+      (file_path == "/system/bin/linker" ||
+       file_path == "/system/bin/linker64")) {
+    return true;
+  }
 
-    return false;
+  return false;
 }
 
-void
-DYLDRendezvous::UpdateBaseAddrIfNecessary(SOEntry &entry, std::string const &file_path)
-{
-    // If the load bias reported by the linker is incorrect then fetch the load address of the file
-    // from the proc file system.
-    if (isLoadBiasIncorrect(m_process->GetTarget(), file_path))
-    {
-        lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
-        bool is_loaded = false;
-        Error error = m_process->GetFileLoadAddress(entry.file_spec, is_loaded, load_addr);
-        if (error.Success() && is_loaded)
-            entry.base_addr = load_addr;
-    }
+void DYLDRendezvous::UpdateBaseAddrIfNecessary(SOEntry &entry,
+                                               std::string const &file_path) {
+  // If the load bias reported by the linker is incorrect then fetch the load
+  // address of the file
+  // from the proc file system.
+  if (isLoadBiasIncorrect(m_process->GetTarget(), file_path)) {
+    lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+    bool is_loaded = false;
+    Error error =
+        m_process->GetFileLoadAddress(entry.file_spec, is_loaded, load_addr);
+    if (error.Success() && is_loaded)
+      entry.base_addr = load_addr;
+  }
 }
 
-bool
-DYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry)
-{
-    entry.clear();
+bool DYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry) {
+  entry.clear();
 
-    entry.link_addr = addr;
-    
-    if (!(addr = ReadPointer(addr, &entry.base_addr)))
-        return false;
+  entry.link_addr = addr;
 
-    // mips adds an extra load offset field to the link map struct on
-    // FreeBSD and NetBSD (need to validate other OSes).
-    // http://svnweb.freebsd.org/base/head/sys/sys/link_elf.h?revision=217153&view=markup#l57
-    const ArchSpec &arch = m_process->GetTarget().GetArchitecture();
-    if ((arch.GetTriple().getOS() == llvm::Triple::FreeBSD 
-        || arch.GetTriple().getOS() == llvm::Triple::NetBSD) && 
-        (arch.GetMachine() == llvm::Triple::mips || arch.GetMachine() == llvm::Triple::mipsel
-        || arch.GetMachine() == llvm::Triple::mips64 || arch.GetMachine() == llvm::Triple::mips64el))
-    {
-        addr_t mips_l_offs;
-        if (!(addr = ReadPointer(addr, &mips_l_offs)))
-            return false;
-        if (mips_l_offs != 0 && mips_l_offs != entry.base_addr)
-            return false;
-    }
-    
-    if (!(addr = ReadPointer(addr, &entry.path_addr)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.dyn_addr)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.next)))
-        return false;
-    
-    if (!(addr = ReadPointer(addr, &entry.prev)))
-        return false;
+  if (!(addr = ReadPointer(addr, &entry.base_addr)))
+    return false;
 
-    std::string file_path = ReadStringFromMemory(entry.path_addr);
-    entry.file_spec.SetFile(file_path, false);
+  // mips adds an extra load offset field to the link map struct on
+  // FreeBSD and NetBSD (need to validate other OSes).
+  // http://svnweb.freebsd.org/base/head/sys/sys/link_elf.h?revision=217153&view=markup#l57
+  const ArchSpec &arch = m_process->GetTarget().GetArchitecture();
+  if ((arch.GetTriple().getOS() == llvm::Triple::FreeBSD ||
+       arch.GetTriple().getOS() == llvm::Triple::NetBSD) &&
+      (arch.GetMachine() == llvm::Triple::mips ||
+       arch.GetMachine() == llvm::Triple::mipsel ||
+       arch.GetMachine() == llvm::Triple::mips64 ||
+       arch.GetMachine() == llvm::Triple::mips64el)) {
+    addr_t mips_l_offs;
+    if (!(addr = ReadPointer(addr, &mips_l_offs)))
+      return false;
+    if (mips_l_offs != 0 && mips_l_offs != entry.base_addr)
+      return false;
+  }
+
+  if (!(addr = ReadPointer(addr, &entry.path_addr)))
+    return false;
 
-    UpdateBaseAddrIfNecessary(entry, file_path);
+  if (!(addr = ReadPointer(addr, &entry.dyn_addr)))
+    return false;
 
-    return true;
-}
+  if (!(addr = ReadPointer(addr, &entry.next)))
+    return false;
 
+  if (!(addr = ReadPointer(addr, &entry.prev)))
+    return false;
 
-bool
-DYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
-{
-    Target& target = m_process->GetTarget();
+  std::string file_path = ReadStringFromMemory(entry.path_addr);
+  entry.file_spec.SetFile(file_path, false);
 
-    SymbolContextList list;
-    if (!target.GetImages().FindSymbolsWithNameAndType (ConstString(name), eSymbolTypeAny, list))
-        return false;
+  UpdateBaseAddrIfNecessary(entry, file_path);
 
-    Address address = list[0].symbol->GetAddress();
-    addr_t addr = address.GetLoadAddress (&target);
-    if (addr == LLDB_INVALID_ADDRESS)
-        return false;
+  return true;
+}
 
-    Error error;
-    value = (uint32_t)m_process->ReadUnsignedIntegerFromMemory(addr + field*sizeof(uint32_t), sizeof(uint32_t), 0, error);
-    if (error.Fail())
-        return false;
+bool DYLDRendezvous::FindMetadata(const char *name, PThreadField field,
+                                  uint32_t &value) {
+  Target &target = m_process->GetTarget();
 
-    if (field == eSize)
-        value /= 8; // convert bits to bytes
+  SymbolContextList list;
+  if (!target.GetImages().FindSymbolsWithNameAndType(ConstString(name),
+                                                     eSymbolTypeAny, list))
+    return false;
 
-    return true;
+  Address address = list[0].symbol->GetAddress();
+  addr_t addr = address.GetLoadAddress(&target);
+  if (addr == LLDB_INVALID_ADDRESS)
+    return false;
+
+  Error error;
+  value = (uint32_t)m_process->ReadUnsignedIntegerFromMemory(
+      addr + field * sizeof(uint32_t), sizeof(uint32_t), 0, error);
+  if (error.Fail())
+    return false;
+
+  if (field == eSize)
+    value /= 8; // convert bits to bytes
+
+  return true;
 }
 
-const DYLDRendezvous::ThreadInfo&
-DYLDRendezvous::GetThreadInfo()
-{
-    if (!m_thread_info.valid)
-    {
-        bool ok = true;
+const DYLDRendezvous::ThreadInfo &DYLDRendezvous::GetThreadInfo() {
+  if (!m_thread_info.valid) {
+    bool ok = true;
 
-        ok &= FindMetadata ("_thread_db_pthread_dtvp", eOffset, m_thread_info.dtv_offset);
-        ok &= FindMetadata ("_thread_db_dtv_dtv", eSize, m_thread_info.dtv_slot_size);
-        ok &= FindMetadata ("_thread_db_link_map_l_tls_modid", eOffset, m_thread_info.modid_offset);
-        ok &= FindMetadata ("_thread_db_dtv_t_pointer_val", eOffset, m_thread_info.tls_offset);
+    ok &= FindMetadata("_thread_db_pthread_dtvp", eOffset,
+                       m_thread_info.dtv_offset);
+    ok &=
+        FindMetadata("_thread_db_dtv_dtv", eSize, m_thread_info.dtv_slot_size);
+    ok &= FindMetadata("_thread_db_link_map_l_tls_modid", eOffset,
+                       m_thread_info.modid_offset);
+    ok &= FindMetadata("_thread_db_dtv_t_pointer_val", eOffset,
+                       m_thread_info.tls_offset);
 
-        if (ok)
-            m_thread_info.valid = true;
-    }
+    if (ok)
+      m_thread_info.valid = true;
+  }
 
-    return m_thread_info;
+  return m_thread_info;
 }
 
-void
-DYLDRendezvous::DumpToLog(Log *log) const
-{
-    int state = GetState();
-
-    if (!log)
-        return;
-
-    log->PutCString("DYLDRendezvous:");
-    log->Printf("   Address: %" PRIx64, GetRendezvousAddress());
-    log->Printf("   Version: %" PRIu64, GetVersion());
-    log->Printf("   Link   : %" PRIx64, GetLinkMapAddress());
-    log->Printf("   Break  : %" PRIx64, GetBreakAddress());
-    log->Printf("   LDBase : %" PRIx64, GetLDBase());
-    log->Printf("   State  : %s", 
-                (state == eConsistent) ? "consistent" :
-                (state == eAdd)        ? "add"        :
-                (state == eDelete)     ? "delete"     : "unknown");
-    
-    iterator I = begin();
-    iterator E = end();
-
-    if (I != E) 
-        log->PutCString("DYLDRendezvous SOEntries:");
-    
-    for (int i = 1; I != E; ++I, ++i) 
-    {
-        log->Printf("\n   SOEntry [%d] %s", i, I->file_spec.GetCString());
-        log->Printf("      Base : %" PRIx64, I->base_addr);
-        log->Printf("      Path : %" PRIx64, I->path_addr);
-        log->Printf("      Dyn  : %" PRIx64, I->dyn_addr);
-        log->Printf("      Next : %" PRIx64, I->next);
-        log->Printf("      Prev : %" PRIx64, I->prev);
-    }
+void DYLDRendezvous::DumpToLog(Log *log) const {
+  int state = GetState();
+
+  if (!log)
+    return;
+
+  log->PutCString("DYLDRendezvous:");
+  log->Printf("   Address: %" PRIx64, GetRendezvousAddress());
+  log->Printf("   Version: %" PRIu64, GetVersion());
+  log->Printf("   Link   : %" PRIx64, GetLinkMapAddress());
+  log->Printf("   Break  : %" PRIx64, GetBreakAddress());
+  log->Printf("   LDBase : %" PRIx64, GetLDBase());
+  log->Printf("   State  : %s",
+              (state == eConsistent)
+                  ? "consistent"
+                  : (state == eAdd) ? "add" : (state == eDelete) ? "delete"
+                                                                 : "unknown");
+
+  iterator I = begin();
+  iterator E = end();
+
+  if (I != E)
+    log->PutCString("DYLDRendezvous SOEntries:");
+
+  for (int i = 1; I != E; ++I, ++i) {
+    log->Printf("\n   SOEntry [%d] %s", i, I->file_spec.GetCString());
+    log->Printf("      Base : %" PRIx64, I->base_addr);
+    log->Printf("      Path : %" PRIx64, I->path_addr);
+    log->Printf("      Dyn  : %" PRIx64, I->dyn_addr);
+    log->Printf("      Next : %" PRIx64, I->next);
+    log->Printf("      Prev : %" PRIx64, I->prev);
+  }
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h
index 8498116..55b8bd7 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h
@@ -16,9 +16,9 @@
 #include <string>
 
 // Other libraries and framework includes
+#include "lldb/Host/FileSpec.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
-#include "lldb/Host/FileSpec.h"
 
 #include "lldb/Core/LoadedModuleInfoList.h"
 
@@ -37,251 +37,220 @@ class Process;
 /// currently loaded modules.
 class DYLDRendezvous {
 
-    // This structure is used to hold the contents of the debug rendezvous
-    // information (struct r_debug) as found in the inferiors memory.  Note that
-    // the layout of this struct is not binary compatible, it is simply large
-    // enough to hold the information on both 32 and 64 bit platforms.
-    struct Rendezvous {
-        uint64_t     version;
-        lldb::addr_t map_addr;
-        lldb::addr_t brk;
-        uint64_t     state;
-        lldb::addr_t ldbase;
-
-        Rendezvous()
-            : version(0), map_addr(0), brk(0), state(0), ldbase(0) { }
-    };
+  // This structure is used to hold the contents of the debug rendezvous
+  // information (struct r_debug) as found in the inferiors memory.  Note that
+  // the layout of this struct is not binary compatible, it is simply large
+  // enough to hold the information on both 32 and 64 bit platforms.
+  struct Rendezvous {
+    uint64_t version;
+    lldb::addr_t map_addr;
+    lldb::addr_t brk;
+    uint64_t state;
+    lldb::addr_t ldbase;
+
+    Rendezvous() : version(0), map_addr(0), brk(0), state(0), ldbase(0) {}
+  };
 
 public:
-    // Various metadata supplied by the inferior's threading library to describe
-    // the per-thread state.
-    struct ThreadInfo {
-        bool     valid;         // whether we read valid metadata
-        uint32_t dtv_offset;    // offset of DTV pointer within pthread
-        uint32_t dtv_slot_size; // size of one DTV slot
-        uint32_t modid_offset;  // offset of module ID within link_map
-        uint32_t tls_offset;    // offset of TLS pointer within DTV slot
-    };
-
-    DYLDRendezvous(lldb_private::Process *process);
-
-    /// Update the internal snapshot of runtime linker rendezvous and recompute
-    /// the currently loaded modules.
-    ///
-    /// This method should be called once one start up, then once each time the
-    /// runtime linker enters the function given by GetBreakAddress().
-    ///
-    /// @returns true on success and false on failure.
-    ///
-    /// @see GetBreakAddress().
-    bool 
-    Resolve();
-
-    /// @returns true if this rendezvous has been located in the inferiors
-    /// address space and false otherwise.
-    bool 
-    IsValid();
-
-    /// @returns the address of the rendezvous structure in the inferiors
-    /// address space.
-    lldb::addr_t
-    GetRendezvousAddress() const { return m_rendezvous_addr; }
-
-    /// @returns the version of the rendezvous protocol being used.
-    uint64_t
-    GetVersion() const { return m_current.version; }
-
-    /// @returns address in the inferiors address space containing the linked
-    /// list of shared object descriptors.
-    lldb::addr_t 
-    GetLinkMapAddress() const { return m_current.map_addr; }
-
-    /// A breakpoint should be set at this address and Resolve called on each
-    /// hit.
-    ///
-    /// @returns the address of a function called by the runtime linker each
-    /// time a module is loaded/unloaded, or about to be loaded/unloaded.
-    ///
-    /// @see Resolve()
-    lldb::addr_t
-    GetBreakAddress() const { return m_current.brk; }
-
-    /// Returns the current state of the rendezvous structure.
-    uint64_t
-    GetState() const { return m_current.state; }
-
-    /// @returns the base address of the runtime linker in the inferiors address
-    /// space.
-    lldb::addr_t
-    GetLDBase() const { return m_current.ldbase; }
-
-    /// @returns the thread layout metadata from the inferiors thread library.
-    const ThreadInfo&
-    GetThreadInfo();
-
-    /// @returns true if modules have been loaded into the inferior since the
-    /// last call to Resolve().
-    bool
-    ModulesDidLoad() const { return !m_added_soentries.empty(); }
-
-    /// @returns true if modules have been unloaded from the inferior since the
-    /// last call to Resolve().
-    bool
-    ModulesDidUnload() const { return !m_removed_soentries.empty(); }
-
-    void
-    DumpToLog(lldb_private::Log *log) const;
-
-    /// @brief Constants describing the state of the rendezvous.
-    ///
-    /// @see GetState().
-    enum RendezvousState {
-        eConsistent,
-        eAdd,
-        eDelete
-    };
-
-    /// @brief Structure representing the shared objects currently loaded into
-    /// the inferior process.
-    ///
-    /// This object is a rough analogue to the struct link_map object which
-    /// actually lives in the inferiors memory.
-    struct SOEntry {
-        lldb::addr_t link_addr;           ///< Address of this link_map.
-        lldb::addr_t base_addr;           ///< Base address of the loaded object.
-        lldb::addr_t path_addr;           ///< String naming the shared object.
-        lldb::addr_t dyn_addr;            ///< Dynamic section of shared object.
-        lldb::addr_t next;                ///< Address of next so_entry.
-        lldb::addr_t prev;                ///< Address of previous so_entry.
-        lldb_private::FileSpec file_spec; ///< File spec of shared object.
-
-        SOEntry() { clear(); }
-
-        bool operator ==(const SOEntry &entry) {
-            return file_spec == entry.file_spec;
-        }
-
-        void clear() {
-            link_addr = 0;
-            base_addr = 0;
-            path_addr = 0;
-            dyn_addr  = 0;
-            next = 0;
-            prev = 0;
-            file_spec.Clear();
-        }
-    };
+  // Various metadata supplied by the inferior's threading library to describe
+  // the per-thread state.
+  struct ThreadInfo {
+    bool valid;             // whether we read valid metadata
+    uint32_t dtv_offset;    // offset of DTV pointer within pthread
+    uint32_t dtv_slot_size; // size of one DTV slot
+    uint32_t modid_offset;  // offset of module ID within link_map
+    uint32_t tls_offset;    // offset of TLS pointer within DTV slot
+  };
+
+  DYLDRendezvous(lldb_private::Process *process);
+
+  /// Update the internal snapshot of runtime linker rendezvous and recompute
+  /// the currently loaded modules.
+  ///
+  /// This method should be called once one start up, then once each time the
+  /// runtime linker enters the function given by GetBreakAddress().
+  ///
+  /// @returns true on success and false on failure.
+  ///
+  /// @see GetBreakAddress().
+  bool Resolve();
+
+  /// @returns true if this rendezvous has been located in the inferiors
+  /// address space and false otherwise.
+  bool IsValid();
+
+  /// @returns the address of the rendezvous structure in the inferiors
+  /// address space.
+  lldb::addr_t GetRendezvousAddress() const { return m_rendezvous_addr; }
+
+  /// @returns the version of the rendezvous protocol being used.
+  uint64_t GetVersion() const { return m_current.version; }
+
+  /// @returns address in the inferiors address space containing the linked
+  /// list of shared object descriptors.
+  lldb::addr_t GetLinkMapAddress() const { return m_current.map_addr; }
+
+  /// A breakpoint should be set at this address and Resolve called on each
+  /// hit.
+  ///
+  /// @returns the address of a function called by the runtime linker each
+  /// time a module is loaded/unloaded, or about to be loaded/unloaded.
+  ///
+  /// @see Resolve()
+  lldb::addr_t GetBreakAddress() const { return m_current.brk; }
+
+  /// Returns the current state of the rendezvous structure.
+  uint64_t GetState() const { return m_current.state; }
+
+  /// @returns the base address of the runtime linker in the inferiors address
+  /// space.
+  lldb::addr_t GetLDBase() const { return m_current.ldbase; }
+
+  /// @returns the thread layout metadata from the inferiors thread library.
+  const ThreadInfo &GetThreadInfo();
+
+  /// @returns true if modules have been loaded into the inferior since the
+  /// last call to Resolve().
+  bool ModulesDidLoad() const { return !m_added_soentries.empty(); }
+
+  /// @returns true if modules have been unloaded from the inferior since the
+  /// last call to Resolve().
+  bool ModulesDidUnload() const { return !m_removed_soentries.empty(); }
+
+  void DumpToLog(lldb_private::Log *log) const;
+
+  /// @brief Constants describing the state of the rendezvous.
+  ///
+  /// @see GetState().
+  enum RendezvousState { eConsistent, eAdd, eDelete };
+
+  /// @brief Structure representing the shared objects currently loaded into
+  /// the inferior process.
+  ///
+  /// This object is a rough analogue to the struct link_map object which
+  /// actually lives in the inferiors memory.
+  struct SOEntry {
+    lldb::addr_t link_addr;           ///< Address of this link_map.
+    lldb::addr_t base_addr;           ///< Base address of the loaded object.
+    lldb::addr_t path_addr;           ///< String naming the shared object.
+    lldb::addr_t dyn_addr;            ///< Dynamic section of shared object.
+    lldb::addr_t next;                ///< Address of next so_entry.
+    lldb::addr_t prev;                ///< Address of previous so_entry.
+    lldb_private::FileSpec file_spec; ///< File spec of shared object.
+
+    SOEntry() { clear(); }
+
+    bool operator==(const SOEntry &entry) {
+      return file_spec == entry.file_spec;
+    }
+
+    void clear() {
+      link_addr = 0;
+      base_addr = 0;
+      path_addr = 0;
+      dyn_addr = 0;
+      next = 0;
+      prev = 0;
+      file_spec.Clear();
+    }
+  };
 
 protected:
-    typedef std::list<SOEntry> SOEntryList;
+  typedef std::list<SOEntry> SOEntryList;
 
 public:
-    typedef SOEntryList::const_iterator iterator;
-
-    /// Iterators over all currently loaded modules.
-    iterator begin() const { return m_soentries.begin(); }
-    iterator end() const { return m_soentries.end(); }
-
-    /// Iterators over all modules loaded into the inferior since the last call
-    /// to Resolve().
-    iterator loaded_begin() const { return m_added_soentries.begin(); }
-    iterator loaded_end() const { return m_added_soentries.end(); }
-
-    /// Iterators over all modules unloaded from the inferior since the last
-    /// call to Resolve().
-    iterator unloaded_begin() const { return m_removed_soentries.begin(); }
-    iterator unloaded_end() const { return m_removed_soentries.end(); }
-    
+  typedef SOEntryList::const_iterator iterator;
+
+  /// Iterators over all currently loaded modules.
+  iterator begin() const { return m_soentries.begin(); }
+  iterator end() const { return m_soentries.end(); }
+
+  /// Iterators over all modules loaded into the inferior since the last call
+  /// to Resolve().
+  iterator loaded_begin() const { return m_added_soentries.begin(); }
+  iterator loaded_end() const { return m_added_soentries.end(); }
+
+  /// Iterators over all modules unloaded from the inferior since the last
+  /// call to Resolve().
+  iterator unloaded_begin() const { return m_removed_soentries.begin(); }
+  iterator unloaded_end() const { return m_removed_soentries.end(); }
+
 protected:
-    lldb_private::Process *m_process;
+  lldb_private::Process *m_process;
 
-    // Cached copy of executable file spec
-    lldb_private::FileSpec m_exe_file_spec;
+  // Cached copy of executable file spec
+  lldb_private::FileSpec m_exe_file_spec;
 
-    /// Location of the r_debug structure in the inferiors address space.
-    lldb::addr_t m_rendezvous_addr;
+  /// Location of the r_debug structure in the inferiors address space.
+  lldb::addr_t m_rendezvous_addr;
 
-    /// Current and previous snapshots of the rendezvous structure.
-    Rendezvous m_current;
-    Rendezvous m_previous;
+  /// Current and previous snapshots of the rendezvous structure.
+  Rendezvous m_current;
+  Rendezvous m_previous;
 
-    /// List of currently loaded SO modules
-    LoadedModuleInfoList m_loaded_modules;
+  /// List of currently loaded SO modules
+  LoadedModuleInfoList m_loaded_modules;
 
-    /// List of SOEntry objects corresponding to the current link map state.
-    SOEntryList m_soentries;
+  /// List of SOEntry objects corresponding to the current link map state.
+  SOEntryList m_soentries;
 
-    /// List of SOEntry's added to the link map since the last call to Resolve().
-    SOEntryList m_added_soentries;
+  /// List of SOEntry's added to the link map since the last call to Resolve().
+  SOEntryList m_added_soentries;
 
-    /// List of SOEntry's removed from the link map since the last call to
-    /// Resolve().
-    SOEntryList m_removed_soentries;
+  /// List of SOEntry's removed from the link map since the last call to
+  /// Resolve().
+  SOEntryList m_removed_soentries;
 
-    /// Threading metadata read from the inferior.
-    ThreadInfo  m_thread_info;
+  /// Threading metadata read from the inferior.
+  ThreadInfo m_thread_info;
 
-    /// Reads an unsigned integer of @p size bytes from the inferior's address
-    /// space starting at @p addr.
-    ///
-    /// @returns addr + size if the read was successful and false otherwise.
-    lldb::addr_t
-    ReadWord(lldb::addr_t addr, uint64_t *dst, size_t size);
+  /// Reads an unsigned integer of @p size bytes from the inferior's address
+  /// space starting at @p addr.
+  ///
+  /// @returns addr + size if the read was successful and false otherwise.
+  lldb::addr_t ReadWord(lldb::addr_t addr, uint64_t *dst, size_t size);
 
-    /// Reads an address from the inferior's address space starting at @p addr.
-    ///
-    /// @returns addr + target address size if the read was successful and
-    /// 0 otherwise.
-    lldb::addr_t
-    ReadPointer(lldb::addr_t addr, lldb::addr_t *dst);
+  /// Reads an address from the inferior's address space starting at @p addr.
+  ///
+  /// @returns addr + target address size if the read was successful and
+  /// 0 otherwise.
+  lldb::addr_t ReadPointer(lldb::addr_t addr, lldb::addr_t *dst);
 
-    /// Reads a null-terminated C string from the memory location starting at @p
-    /// addr.
-    std::string
-    ReadStringFromMemory(lldb::addr_t addr);
+  /// Reads a null-terminated C string from the memory location starting at @p
+  /// addr.
+  std::string ReadStringFromMemory(lldb::addr_t addr);
 
-    /// Reads an SOEntry starting at @p addr.
-    bool
-    ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry);
+  /// Reads an SOEntry starting at @p addr.
+  bool ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry);
 
-    /// Updates the current set of SOEntries, the set of added entries, and the
-    /// set of removed entries.
-    bool
-    UpdateSOEntries(bool fromRemote = false);
+  /// Updates the current set of SOEntries, the set of added entries, and the
+  /// set of removed entries.
+  bool UpdateSOEntries(bool fromRemote = false);
 
-    bool
-    FillSOEntryFromModuleInfo (LoadedModuleInfoList::LoadedModuleInfo const & modInfo,
-                               SOEntry &entry);
+  bool FillSOEntryFromModuleInfo(
+      LoadedModuleInfoList::LoadedModuleInfo const &modInfo, SOEntry &entry);
 
-    bool
-    SaveSOEntriesFromRemote(LoadedModuleInfoList &module_list);
+  bool SaveSOEntriesFromRemote(LoadedModuleInfoList &module_list);
 
-    bool
-    AddSOEntriesFromRemote(LoadedModuleInfoList &module_list);
+  bool AddSOEntriesFromRemote(LoadedModuleInfoList &module_list);
 
-    bool
-    RemoveSOEntriesFromRemote(LoadedModuleInfoList &module_list);
+  bool RemoveSOEntriesFromRemote(LoadedModuleInfoList &module_list);
 
-    bool
-    AddSOEntries();
+  bool AddSOEntries();
 
-    bool
-    RemoveSOEntries();
+  bool RemoveSOEntries();
 
-    void
-    UpdateBaseAddrIfNecessary(SOEntry &entry, std::string const &file_path);
+  void UpdateBaseAddrIfNecessary(SOEntry &entry, std::string const &file_path);
 
-    bool
-    SOEntryIsMainExecutable(const SOEntry &entry);
+  bool SOEntryIsMainExecutable(const SOEntry &entry);
 
-    /// Reads the current list of shared objects according to the link map
-    /// supplied by the runtime linker.
-    bool
-    TakeSnapshot(SOEntryList &entry_list);
+  /// Reads the current list of shared objects according to the link map
+  /// supplied by the runtime linker.
+  bool TakeSnapshot(SOEntryList &entry_list);
 
-    enum PThreadField { eSize, eNElem, eOffset };
+  enum PThreadField { eSize, eNElem, eOffset };
 
-    bool FindMetadata(const char *name, PThreadField field, uint32_t& value);
+  bool FindMetadata(const char *name, PThreadField field, uint32_t &value);
 };
 
 #endif
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
index 6515c02..fc225ee 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
@@ -1,4 +1,4 @@
-//===-- DynamicLoaderPOSIX.h ------------------------------------*- C++ -*-===//
+//===-- DynamicLoaderPOSIXDYLD.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,280 +7,267 @@
 //
 //===----------------------------------------------------------------------===//
 
-// C Includes
-// C++ Includes
+// Main header include
+#include "DynamicLoaderPOSIXDYLD.h"
+
+// Project includes
+#include "AuxVector.h"
+
 // Other libraries and framework includes
-#include "lldb/Core/PluginManager.h"
+#include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Target/Platform.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
-#include "lldb/Breakpoint/BreakpointLocation.h"
 
-#include "AuxVector.h"
-#include "DynamicLoaderPOSIXDYLD.h"
+// C++ Includes
+// C Includes
 
 using namespace lldb;
 using namespace lldb_private;
 
-void
-DynamicLoaderPOSIXDYLD::Initialize()
-{
-    PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                  GetPluginDescriptionStatic(),
-                                  CreateInstance);
+void DynamicLoaderPOSIXDYLD::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance);
 }
 
-void
-DynamicLoaderPOSIXDYLD::Terminate()
-{
-}
+void DynamicLoaderPOSIXDYLD::Terminate() {}
 
-lldb_private::ConstString
-DynamicLoaderPOSIXDYLD::GetPluginName()
-{
-    return GetPluginNameStatic();
+lldb_private::ConstString DynamicLoaderPOSIXDYLD::GetPluginName() {
+  return GetPluginNameStatic();
 }
 
-lldb_private::ConstString
-DynamicLoaderPOSIXDYLD::GetPluginNameStatic()
-{
-    static ConstString g_name("linux-dyld");
-    return g_name;
+lldb_private::ConstString DynamicLoaderPOSIXDYLD::GetPluginNameStatic() {
+  static ConstString g_name("linux-dyld");
+  return g_name;
 }
 
-const char *
-DynamicLoaderPOSIXDYLD::GetPluginDescriptionStatic()
-{
-    return "Dynamic loader plug-in that watches for shared library "
-           "loads/unloads in POSIX processes.";
+const char *DynamicLoaderPOSIXDYLD::GetPluginDescriptionStatic() {
+  return "Dynamic loader plug-in that watches for shared library "
+         "loads/unloads in POSIX processes.";
 }
 
-uint32_t
-DynamicLoaderPOSIXDYLD::GetPluginVersion()
-{
-    return 1;
-}
-
-DynamicLoader *
-DynamicLoaderPOSIXDYLD::CreateInstance(Process *process, bool force)
-{
-    bool create = force;
-    if (!create)
-    {
-        const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
-        if (triple_ref.getOS() == llvm::Triple::Linux ||
-            triple_ref.getOS() == llvm::Triple::FreeBSD)
-            create = true;
-    }
-    
-    if (create)
-        return new DynamicLoaderPOSIXDYLD (process);
-    return NULL;
+uint32_t DynamicLoaderPOSIXDYLD::GetPluginVersion() { return 1; }
+
+DynamicLoader *DynamicLoaderPOSIXDYLD::CreateInstance(Process *process,
+                                                      bool force) {
+  bool create = force;
+  if (!create) {
+    const llvm::Triple &triple_ref =
+        process->GetTarget().GetArchitecture().GetTriple();
+    if (triple_ref.getOS() == llvm::Triple::Linux ||
+        triple_ref.getOS() == llvm::Triple::FreeBSD)
+      create = true;
+  }
+
+  if (create)
+    return new DynamicLoaderPOSIXDYLD(process);
+  return NULL;
 }
 
 DynamicLoaderPOSIXDYLD::DynamicLoaderPOSIXDYLD(Process *process)
-    : DynamicLoader(process),
-      m_rendezvous(process),
-      m_load_offset(LLDB_INVALID_ADDRESS),
-      m_entry_point(LLDB_INVALID_ADDRESS),
-      m_auxv(),
-      m_dyld_bid(LLDB_INVALID_BREAK_ID),
-      m_vdso_base(LLDB_INVALID_ADDRESS)
-{
+    : DynamicLoader(process), m_rendezvous(process),
+      m_load_offset(LLDB_INVALID_ADDRESS), m_entry_point(LLDB_INVALID_ADDRESS),
+      m_auxv(), m_dyld_bid(LLDB_INVALID_BREAK_ID),
+      m_vdso_base(LLDB_INVALID_ADDRESS) {}
+
+DynamicLoaderPOSIXDYLD::~DynamicLoaderPOSIXDYLD() {
+  if (m_dyld_bid != LLDB_INVALID_BREAK_ID) {
+    m_process->GetTarget().RemoveBreakpointByID(m_dyld_bid);
+    m_dyld_bid = LLDB_INVALID_BREAK_ID;
+  }
 }
 
-DynamicLoaderPOSIXDYLD::~DynamicLoaderPOSIXDYLD()
-{
-    if (m_dyld_bid != LLDB_INVALID_BREAK_ID)
-    {
-        m_process->GetTarget().RemoveBreakpointByID (m_dyld_bid);
-        m_dyld_bid = LLDB_INVALID_BREAK_ID;
+void DynamicLoaderPOSIXDYLD::DidAttach() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__,
+                m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
+
+  m_auxv.reset(new AuxVector(m_process));
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data",
+                __FUNCTION__,
+                m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
+
+  // ask the process if it can load any of its own modules
+  m_process->LoadModules();
+
+  ModuleSP executable_sp = GetTargetExecutable();
+  ResolveExecutableModule(executable_sp);
+
+  // find the main process load offset
+  addr_t load_offset = ComputeLoadOffset();
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                " executable '%s', load_offset 0x%" PRIx64,
+                __FUNCTION__,
+                m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID,
+                executable_sp ? executable_sp->GetFileSpec().GetPath().c_str()
+                              : "<null executable>",
+                load_offset);
+
+  EvalVdsoStatus();
+
+  // if we dont have a load address we cant re-base
+  bool rebase_exec = (load_offset == LLDB_INVALID_ADDRESS) ? false : true;
+
+  // if we have a valid executable
+  if (executable_sp.get()) {
+    lldb_private::ObjectFile *obj = executable_sp->GetObjectFile();
+    if (obj) {
+      // don't rebase if the module already has a load address
+      Target &target = m_process->GetTarget();
+      Address addr = obj->GetImageInfoAddress(&target);
+      if (addr.GetLoadAddress(&target) != LLDB_INVALID_ADDRESS)
+        rebase_exec = false;
     }
-}
+  } else {
+    // no executable, nothing to re-base
+    rebase_exec = false;
+  }
 
-void
-DynamicLoaderPOSIXDYLD::DidAttach()
-{
-    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-
-    m_auxv.reset(new AuxVector(m_process));
-    if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-
-    // ask the process if it can load any of its own modules
-    m_process->LoadModules ();
-
-    ModuleSP executable_sp = GetTargetExecutable ();
-    ResolveExecutableModule (executable_sp);
+  // if the target executable should be re-based
+  if (rebase_exec) {
+    ModuleList module_list;
 
-    // find the main process load offset
-    addr_t load_offset = ComputeLoadOffset ();
+    module_list.Append(executable_sp);
     if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " executable '%s', load_offset 0x%" PRIx64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, executable_sp ? executable_sp->GetFileSpec().GetPath().c_str () : "<null executable>", load_offset);
-
-    EvalVdsoStatus();
-
-    // if we dont have a load address we cant re-base
-    bool rebase_exec = (load_offset == LLDB_INVALID_ADDRESS) ? false : true;
-
-    // if we have a valid executable
-    if (executable_sp.get())
-    {
-        lldb_private::ObjectFile * obj = executable_sp->GetObjectFile();
-        if (obj)
-        {
-            // don't rebase if the module already has a load address
-            Target & target = m_process->GetTarget ();
-            Address addr = obj->GetImageInfoAddress (&target);
-            if (addr.GetLoadAddress (&target) != LLDB_INVALID_ADDRESS)
-                rebase_exec = false;
-        }
-    }
-    else
-    {
-        // no executable, nothing to re-base
-        rebase_exec = false;
+      log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                  " added executable '%s' to module load list",
+                  __FUNCTION__,
+                  m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID,
+                  executable_sp->GetFileSpec().GetPath().c_str());
+
+    UpdateLoadedSections(executable_sp, LLDB_INVALID_ADDRESS, load_offset,
+                         true);
+
+    // When attaching to a target, there are two possible states:
+    // (1) We already crossed the entry point and therefore the rendezvous
+    //     structure is ready to be used and we can load the list of modules
+    //     and place the rendezvous breakpoint.
+    // (2) We didn't cross the entry point yet, so these structures are not
+    //     ready; we should behave as if we just launched the target and
+    //     call ProbeEntry(). This will place a breakpoint on the entry
+    //     point which itself will be hit after the rendezvous structure is
+    //     set up and will perform actions described in (1).
+    if (m_rendezvous.Resolve()) {
+      if (log)
+        log->Printf("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64
+                    " rendezvous could resolve: attach assuming dynamic loader "
+                    "info is available now",
+                    __FUNCTION__,
+                    m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
+      LoadAllCurrentModules();
+      SetRendezvousBreakpoint();
+    } else {
+      if (log)
+        log->Printf("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64
+                    " rendezvous could not yet resolve: adding breakpoint to "
+                    "catch future rendezvous setup",
+                    __FUNCTION__,
+                    m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
+      ProbeEntry();
     }
 
-    // if the target executable should be re-based
-    if (rebase_exec)
-    {
-        ModuleList module_list;
-
-        module_list.Append(executable_sp);
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " added executable '%s' to module load list",
-                         __FUNCTION__,
-                         m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID,
-                         executable_sp->GetFileSpec().GetPath().c_str ());
-
-        UpdateLoadedSections(executable_sp, LLDB_INVALID_ADDRESS, load_offset, true);
-
-        // When attaching to a target, there are two possible states:
-        // (1) We already crossed the entry point and therefore the rendezvous
-        //     structure is ready to be used and we can load the list of modules
-        //     and place the rendezvous breakpoint.
-        // (2) We didn't cross the entry point yet, so these structures are not
-        //     ready; we should behave as if we just launched the target and
-        //     call ProbeEntry(). This will place a breakpoint on the entry
-        //     point which itself will be hit after the rendezvous structure is
-        //     set up and will perform actions described in (1).
-        if (m_rendezvous.Resolve())
-        {
-            if (log)
-                log->Printf ("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64 " rendezvous could resolve: attach assuming dynamic loader info is available now", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-            LoadAllCurrentModules();
-            SetRendezvousBreakpoint();
-        }
-        else
-        {
-            if (log)
-                log->Printf ("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64 " rendezvous could not yet resolve: adding breakpoint to catch future rendezvous setup", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-            ProbeEntry();
-        }
-
-        m_process->GetTarget().ModulesDidLoad(module_list);
-        if (log)
-        {
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s told the target about the modules that loaded:", __FUNCTION__);
-            for (auto module_sp : module_list.Modules ())
-            {
-                log->Printf ("-- [module] %s (pid %" PRIu64 ")",
-                             module_sp ? module_sp->GetFileSpec().GetPath().c_str () : "<null>",
-                             m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-            }
-        }
+    m_process->GetTarget().ModulesDidLoad(module_list);
+    if (log) {
+      log->Printf("DynamicLoaderPOSIXDYLD::%s told the target about the "
+                  "modules that loaded:",
+                  __FUNCTION__);
+      for (auto module_sp : module_list.Modules()) {
+        log->Printf("-- [module] %s (pid %" PRIu64 ")",
+                    module_sp ? module_sp->GetFileSpec().GetPath().c_str()
+                              : "<null>",
+                    m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
+      }
     }
+  }
 }
 
-void
-DynamicLoaderPOSIXDYLD::DidLaunch()
-{
-    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s()", __FUNCTION__);
+void DynamicLoaderPOSIXDYLD::DidLaunch() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s()", __FUNCTION__);
 
-    ModuleSP executable;
-    addr_t load_offset;
+  ModuleSP executable;
+  addr_t load_offset;
 
-    m_auxv.reset(new AuxVector(m_process));
+  m_auxv.reset(new AuxVector(m_process));
 
-    executable = GetTargetExecutable();
-    load_offset = ComputeLoadOffset();
-    EvalVdsoStatus();
+  executable = GetTargetExecutable();
+  load_offset = ComputeLoadOffset();
+  EvalVdsoStatus();
 
-    if (executable.get() && load_offset != LLDB_INVALID_ADDRESS)
-    {
-        ModuleList module_list;
-        module_list.Append(executable);
-        UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
+  if (executable.get() && load_offset != LLDB_INVALID_ADDRESS) {
+    ModuleList module_list;
+    module_list.Append(executable);
+    UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
 
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s about to call ProbeEntry()", __FUNCTION__);
-        ProbeEntry();
+    if (log)
+      log->Printf("DynamicLoaderPOSIXDYLD::%s about to call ProbeEntry()",
+                  __FUNCTION__);
+    ProbeEntry();
 
-        m_process->GetTarget().ModulesDidLoad(module_list);
-    }
+    m_process->GetTarget().ModulesDidLoad(module_list);
+  }
 }
 
-Error
-DynamicLoaderPOSIXDYLD::CanLoadImage()
-{
-    return Error();
-}
+Error DynamicLoaderPOSIXDYLD::CanLoadImage() { return Error(); }
 
-void
-DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
-                                             addr_t link_map_addr,
-                                             addr_t base_addr,
-                                             bool base_addr_is_offset)
-{
-    m_loaded_modules[module] = link_map_addr;
-    UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
+void DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
+                                                  addr_t link_map_addr,
+                                                  addr_t base_addr,
+                                                  bool base_addr_is_offset) {
+  m_loaded_modules[module] = link_map_addr;
+  UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 }
 
-void
-DynamicLoaderPOSIXDYLD::UnloadSections(const ModuleSP module)
-{
-    m_loaded_modules.erase(module);
+void DynamicLoaderPOSIXDYLD::UnloadSections(const ModuleSP module) {
+  m_loaded_modules.erase(module);
 
-    UnloadSectionsCommon(module);
+  UnloadSectionsCommon(module);
 }
 
-void
-DynamicLoaderPOSIXDYLD::ProbeEntry()
-{
-    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-
-    const addr_t entry = GetEntryPoint();
-    if (entry == LLDB_INVALID_ADDRESS)
-    {
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " GetEntryPoint() returned no address, not setting entry breakpoint", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-        return;
-    }
+void DynamicLoaderPOSIXDYLD::ProbeEntry() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
+  const addr_t entry = GetEntryPoint();
+  if (entry == LLDB_INVALID_ADDRESS) {
     if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " GetEntryPoint() returned address 0x%" PRIx64 ", setting entry breakpoint", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, entry);
-
-    if (m_process)
-    {
-        Breakpoint *const entry_break = m_process->GetTarget().CreateBreakpoint(entry, true, false).get();
-        entry_break->SetCallback(EntryBreakpointHit, this, true);
-        entry_break->SetBreakpointKind("shared-library-event");
-
-        // Shoudn't hit this more than once.
-        entry_break->SetOneShot (true);
-    }
+      log->Printf(
+          "DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+          " GetEntryPoint() returned no address, not setting entry breakpoint",
+          __FUNCTION__,
+          m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
+    return;
+  }
+
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                " GetEntryPoint() returned address 0x%" PRIx64
+                ", setting entry breakpoint",
+                __FUNCTION__,
+                m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID,
+                entry);
+
+  if (m_process) {
+    Breakpoint *const entry_break =
+        m_process->GetTarget().CreateBreakpoint(entry, true, false).get();
+    entry_break->SetCallback(EntryBreakpointHit, this, true);
+    entry_break->SetBreakpointKind("shared-library-event");
+
+    // Shoudn't hit this more than once.
+    entry_break->SetOneShot(true);
+  }
 }
 
 // The runtime linker has run and initialized the rendezvous structure once the
@@ -289,405 +276,429 @@ DynamicLoaderPOSIXDYLD::ProbeEntry()
 // dependent modules for the process.  Similarly, we can discover the runtime
 // linker function and setup a breakpoint to notify us of any dynamically loaded
 // modules (via dlopen).
-bool
-DynamicLoaderPOSIXDYLD::EntryBreakpointHit(void *baton, 
-                                           StoppointCallbackContext *context, 
-                                           user_id_t break_id, 
-                                           user_id_t break_loc_id)
-{
-    assert(baton && "null baton");
-    if (!baton)
-        return false;
-
-    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    DynamicLoaderPOSIXDYLD *const dyld_instance = static_cast<DynamicLoaderPOSIXDYLD*>(baton);
-    if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s called for pid %" PRIu64, __FUNCTION__, dyld_instance->m_process ? dyld_instance->m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-
-    // Disable the breakpoint --- if a stop happens right after this, which we've seen on occasion, we don't
-    // want the breakpoint stepping thread-plan logic to show a breakpoint instruction at the disassembled
-    // entry point to the program.  Disabling it prevents it.  (One-shot is not enough - one-shot removal logic
-    // only happens after the breakpoint goes public, which wasn't happening in our scenario).
-    if (dyld_instance->m_process)
-    {
-        BreakpointSP breakpoint_sp = dyld_instance->m_process->GetTarget().GetBreakpointByID (break_id);
-        if (breakpoint_sp)
-        {
-            if (log)
-                log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " disabling breakpoint id %" PRIu64, __FUNCTION__, dyld_instance->m_process->GetID (), break_id);
-            breakpoint_sp->SetEnabled (false);
-        }
-        else
-        {
-            if (log)
-                log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " failed to find breakpoint for breakpoint id %" PRIu64, __FUNCTION__, dyld_instance->m_process->GetID (), break_id);
-        }
-    }
-    else
-    {
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s breakpoint id %" PRIu64 " no Process instance!  Cannot disable breakpoint", __FUNCTION__, break_id);
+bool DynamicLoaderPOSIXDYLD::EntryBreakpointHit(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  assert(baton && "null baton");
+  if (!baton)
+    return false;
+
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  DynamicLoaderPOSIXDYLD *const dyld_instance =
+      static_cast<DynamicLoaderPOSIXDYLD *>(baton);
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s called for pid %" PRIu64,
+                __FUNCTION__,
+                dyld_instance->m_process ? dyld_instance->m_process->GetID()
+                                         : LLDB_INVALID_PROCESS_ID);
+
+  // Disable the breakpoint --- if a stop happens right after this, which we've
+  // seen on occasion, we don't
+  // want the breakpoint stepping thread-plan logic to show a breakpoint
+  // instruction at the disassembled
+  // entry point to the program.  Disabling it prevents it.  (One-shot is not
+  // enough - one-shot removal logic
+  // only happens after the breakpoint goes public, which wasn't happening in
+  // our scenario).
+  if (dyld_instance->m_process) {
+    BreakpointSP breakpoint_sp =
+        dyld_instance->m_process->GetTarget().GetBreakpointByID(break_id);
+    if (breakpoint_sp) {
+      if (log)
+        log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                    " disabling breakpoint id %" PRIu64,
+                    __FUNCTION__, dyld_instance->m_process->GetID(), break_id);
+      breakpoint_sp->SetEnabled(false);
+    } else {
+      if (log)
+        log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                    " failed to find breakpoint for breakpoint id %" PRIu64,
+                    __FUNCTION__, dyld_instance->m_process->GetID(), break_id);
     }
-
-    dyld_instance->LoadAllCurrentModules();
-    dyld_instance->SetRendezvousBreakpoint();
-    return false; // Continue running.
+  } else {
+    if (log)
+      log->Printf("DynamicLoaderPOSIXDYLD::%s breakpoint id %" PRIu64
+                  " no Process instance!  Cannot disable breakpoint",
+                  __FUNCTION__, break_id);
+  }
+
+  dyld_instance->LoadAllCurrentModules();
+  dyld_instance->SetRendezvousBreakpoint();
+  return false; // Continue running.
 }
 
-void
-DynamicLoaderPOSIXDYLD::SetRendezvousBreakpoint()
-{
-    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-
-    addr_t break_addr = m_rendezvous.GetBreakAddress();
-    Target &target = m_process->GetTarget();
-
-    if (m_dyld_bid == LLDB_INVALID_BREAK_ID)
-    {
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " setting rendezvous break address at 0x%" PRIx64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, break_addr);
-        Breakpoint *dyld_break = target.CreateBreakpoint (break_addr, true, false).get();
-        dyld_break->SetCallback(RendezvousBreakpointHit, this, true);
-        dyld_break->SetBreakpointKind ("shared-library-event");
-        m_dyld_bid = dyld_break->GetID();
-    }
-    else
-    {
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reusing break id %" PRIu32 ", address at 0x%" PRIx64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, m_dyld_bid, break_addr);
-    }
+void DynamicLoaderPOSIXDYLD::SetRendezvousBreakpoint() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-    // Make sure our breakpoint is at the right address.
-    assert (target.GetBreakpointByID(m_dyld_bid)->FindLocationByAddress(break_addr)->GetBreakpoint().GetID() == m_dyld_bid);
-}
+  addr_t break_addr = m_rendezvous.GetBreakAddress();
+  Target &target = m_process->GetTarget();
 
-bool
-DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit(void *baton, 
-                                                StoppointCallbackContext *context, 
-                                                user_id_t break_id, 
-                                                user_id_t break_loc_id)
-{
-    assert (baton && "null baton");
-    if (!baton)
-        return false;
-
-    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    DynamicLoaderPOSIXDYLD *const dyld_instance = static_cast<DynamicLoaderPOSIXDYLD*>(baton);
+  if (m_dyld_bid == LLDB_INVALID_BREAK_ID) {
     if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s called for pid %" PRIu64, __FUNCTION__, dyld_instance->m_process ? dyld_instance->m_process->GetID () : LLDB_INVALID_PROCESS_ID);
-
-    dyld_instance->RefreshModules();
-
-    // Return true to stop the target, false to just let the target run.
-    const bool stop_when_images_change = dyld_instance->GetStopWhenImagesChange();
+      log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                  " setting rendezvous break address at 0x%" PRIx64,
+                  __FUNCTION__,
+                  m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID,
+                  break_addr);
+    Breakpoint *dyld_break =
+        target.CreateBreakpoint(break_addr, true, false).get();
+    dyld_break->SetCallback(RendezvousBreakpointHit, this, true);
+    dyld_break->SetBreakpointKind("shared-library-event");
+    m_dyld_bid = dyld_break->GetID();
+  } else {
     if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " stop_when_images_change=%s", __FUNCTION__, dyld_instance->m_process ? dyld_instance->m_process->GetID () : LLDB_INVALID_PROCESS_ID, stop_when_images_change ? "true" : "false");
-    return stop_when_images_change;
+      log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                  " reusing break id %" PRIu32 ", address at 0x%" PRIx64,
+                  __FUNCTION__,
+                  m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID,
+                  m_dyld_bid, break_addr);
+  }
+
+  // Make sure our breakpoint is at the right address.
+  assert(target.GetBreakpointByID(m_dyld_bid)
+             ->FindLocationByAddress(break_addr)
+             ->GetBreakpoint()
+             .GetID() == m_dyld_bid);
+}
+
+bool DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  assert(baton && "null baton");
+  if (!baton)
+    return false;
+
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  DynamicLoaderPOSIXDYLD *const dyld_instance =
+      static_cast<DynamicLoaderPOSIXDYLD *>(baton);
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s called for pid %" PRIu64,
+                __FUNCTION__,
+                dyld_instance->m_process ? dyld_instance->m_process->GetID()
+                                         : LLDB_INVALID_PROCESS_ID);
+
+  dyld_instance->RefreshModules();
+
+  // Return true to stop the target, false to just let the target run.
+  const bool stop_when_images_change = dyld_instance->GetStopWhenImagesChange();
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64
+                " stop_when_images_change=%s",
+                __FUNCTION__,
+                dyld_instance->m_process ? dyld_instance->m_process->GetID()
+                                         : LLDB_INVALID_PROCESS_ID,
+                stop_when_images_change ? "true" : "false");
+  return stop_when_images_change;
 }
 
-void
-DynamicLoaderPOSIXDYLD::RefreshModules()
-{
-    if (!m_rendezvous.Resolve())
-        return;
-
-    DYLDRendezvous::iterator I;
-    DYLDRendezvous::iterator E;
-
-    ModuleList &loaded_modules = m_process->GetTarget().GetImages();
-
-    if (m_rendezvous.ModulesDidLoad()) 
-    {
-        ModuleList new_modules;
-
-        E = m_rendezvous.loaded_end();
-        for (I = m_rendezvous.loaded_begin(); I != E; ++I)
-        {
-            ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
-            if (module_sp.get())
-            {
-                loaded_modules.AppendIfNeeded(module_sp);
-                new_modules.Append(module_sp);
-            }
-        }
-        m_process->GetTarget().ModulesDidLoad(new_modules);
+void DynamicLoaderPOSIXDYLD::RefreshModules() {
+  if (!m_rendezvous.Resolve())
+    return;
+
+  DYLDRendezvous::iterator I;
+  DYLDRendezvous::iterator E;
+
+  ModuleList &loaded_modules = m_process->GetTarget().GetImages();
+
+  if (m_rendezvous.ModulesDidLoad()) {
+    ModuleList new_modules;
+
+    E = m_rendezvous.loaded_end();
+    for (I = m_rendezvous.loaded_begin(); I != E; ++I) {
+      ModuleSP module_sp =
+          LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
+      if (module_sp.get()) {
+        loaded_modules.AppendIfNeeded(module_sp);
+        new_modules.Append(module_sp);
+      }
     }
-    
-    if (m_rendezvous.ModulesDidUnload())
-    {
-        ModuleList old_modules;
-
-        E = m_rendezvous.unloaded_end();
-        for (I = m_rendezvous.unloaded_begin(); I != E; ++I)
-        {
-            ModuleSpec module_spec{I->file_spec};
-            ModuleSP module_sp = loaded_modules.FindFirstModule (module_spec);
-
-            if (module_sp.get())
-            {
-                old_modules.Append(module_sp);
-                UnloadSections(module_sp);
-            }
-        }
-        loaded_modules.Remove(old_modules);
-        m_process->GetTarget().ModulesDidUnload(old_modules, false);
+    m_process->GetTarget().ModulesDidLoad(new_modules);
+  }
+
+  if (m_rendezvous.ModulesDidUnload()) {
+    ModuleList old_modules;
+
+    E = m_rendezvous.unloaded_end();
+    for (I = m_rendezvous.unloaded_begin(); I != E; ++I) {
+      ModuleSpec module_spec{I->file_spec};
+      ModuleSP module_sp = loaded_modules.FindFirstModule(module_spec);
+
+      if (module_sp.get()) {
+        old_modules.Append(module_sp);
+        UnloadSections(module_sp);
+      }
     }
+    loaded_modules.Remove(old_modules);
+    m_process->GetTarget().ModulesDidUnload(old_modules, false);
+  }
 }
 
 ThreadPlanSP
-DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
-{
-    ThreadPlanSP thread_plan_sp;
-
-    StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
-    const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol);
-    Symbol *sym = context.symbol;
-
-    if (sym == NULL || !sym->IsTrampoline())
-        return thread_plan_sp;
-
-    ConstString sym_name = sym->GetName();
-    if (!sym_name)
-        return thread_plan_sp;
-
-    SymbolContextList target_symbols;
-    Target &target = thread.GetProcess()->GetTarget();
-    const ModuleList &images = target.GetImages();
-
-    images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
-    size_t num_targets = target_symbols.GetSize();
-    if (!num_targets)
-        return thread_plan_sp;
-
-    typedef std::vector<lldb::addr_t> AddressVector;
-    AddressVector addrs;
-    for (size_t i = 0; i < num_targets; ++i)
-    {
-        SymbolContext context;
-        AddressRange range;
-        if (target_symbols.GetContextAtIndex(i, context))
-        {
-            context.GetAddressRange(eSymbolContextEverything, 0, false, range);
-            lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
-            if (addr != LLDB_INVALID_ADDRESS)
-                addrs.push_back(addr);
-        }
-    }
+DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread,
+                                                     bool stop) {
+  ThreadPlanSP thread_plan_sp;
 
-    if (addrs.size() > 0) 
-    {
-        AddressVector::iterator start = addrs.begin();
-        AddressVector::iterator end = addrs.end();
+  StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
+  const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol);
+  Symbol *sym = context.symbol;
 
-        std::sort(start, end);
-        addrs.erase(std::unique(start, end), end);
-        thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
-    }
+  if (sym == NULL || !sym->IsTrampoline())
+    return thread_plan_sp;
 
+  ConstString sym_name = sym->GetName();
+  if (!sym_name)
     return thread_plan_sp;
-}
 
-void
-DynamicLoaderPOSIXDYLD::LoadAllCurrentModules()
-{
-    DYLDRendezvous::iterator I;
-    DYLDRendezvous::iterator E;
-    ModuleList module_list;
-    
-    if (!m_rendezvous.Resolve())
-    {
-        Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-        if (log)
-            log->Printf("DynamicLoaderPOSIXDYLD::%s unable to resolve POSIX DYLD rendezvous address",
-                        __FUNCTION__);
-        return;
+  SymbolContextList target_symbols;
+  Target &target = thread.GetProcess()->GetTarget();
+  const ModuleList &images = target.GetImages();
+
+  images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
+  size_t num_targets = target_symbols.GetSize();
+  if (!num_targets)
+    return thread_plan_sp;
+
+  typedef std::vector<lldb::addr_t> AddressVector;
+  AddressVector addrs;
+  for (size_t i = 0; i < num_targets; ++i) {
+    SymbolContext context;
+    AddressRange range;
+    if (target_symbols.GetContextAtIndex(i, context)) {
+      context.GetAddressRange(eSymbolContextEverything, 0, false, range);
+      lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
+      if (addr != LLDB_INVALID_ADDRESS)
+        addrs.push_back(addr);
     }
+  }
+
+  if (addrs.size() > 0) {
+    AddressVector::iterator start = addrs.begin();
+    AddressVector::iterator end = addrs.end();
 
-    // The rendezvous class doesn't enumerate the main module, so track
-    // that ourselves here.
-    ModuleSP executable = GetTargetExecutable();
-    m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
-    if (m_vdso_base != LLDB_INVALID_ADDRESS)
-    {
-        FileSpec file_spec("[vdso]", false);
-        ModuleSP module_sp = LoadModuleAtAddress(file_spec, LLDB_INVALID_ADDRESS, m_vdso_base, false);
-        if (module_sp.get())
-        {
-            module_list.Append(module_sp);
-        }
+    std::sort(start, end);
+    addrs.erase(std::unique(start, end), end);
+    thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
+  }
+
+  return thread_plan_sp;
+}
+
+void DynamicLoaderPOSIXDYLD::LoadAllCurrentModules() {
+  DYLDRendezvous::iterator I;
+  DYLDRendezvous::iterator E;
+  ModuleList module_list;
+
+  if (!m_rendezvous.Resolve()) {
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+    if (log)
+      log->Printf("DynamicLoaderPOSIXDYLD::%s unable to resolve POSIX DYLD "
+                  "rendezvous address",
+                  __FUNCTION__);
+    return;
+  }
+
+  // The rendezvous class doesn't enumerate the main module, so track
+  // that ourselves here.
+  ModuleSP executable = GetTargetExecutable();
+  m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
+  if (m_vdso_base != LLDB_INVALID_ADDRESS) {
+    FileSpec file_spec("[vdso]", false);
+    ModuleSP module_sp = LoadModuleAtAddress(file_spec, LLDB_INVALID_ADDRESS,
+                                             m_vdso_base, false);
+    if (module_sp.get()) {
+      module_list.Append(module_sp);
     }
-    for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
-    {
-        ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
-        if (module_sp.get())
-        {
-            module_list.Append(module_sp);
-        }
-        else
-        {
-            Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-            if (log)
-                log->Printf("DynamicLoaderPOSIXDYLD::%s failed loading module %s at 0x%" PRIx64,
-                            __FUNCTION__, I->file_spec.GetCString(), I->base_addr);
-        }
+  }
+
+  std::vector<FileSpec> module_names;
+  for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
+    module_names.push_back(I->file_spec);
+  m_process->PrefetchModuleSpecs(
+      module_names, m_process->GetTarget().GetArchitecture().GetTriple());
+
+  for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) {
+    ModuleSP module_sp =
+        LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
+    if (module_sp.get()) {
+      module_list.Append(module_sp);
+    } else {
+      Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+      if (log)
+        log->Printf(
+            "DynamicLoaderPOSIXDYLD::%s failed loading module %s at 0x%" PRIx64,
+            __FUNCTION__, I->file_spec.GetCString(), I->base_addr);
     }
+  }
 
-    m_process->GetTarget().ModulesDidLoad(module_list);
+  m_process->GetTarget().ModulesDidLoad(module_list);
 }
 
-addr_t
-DynamicLoaderPOSIXDYLD::ComputeLoadOffset()
-{
-    addr_t virt_entry;
+addr_t DynamicLoaderPOSIXDYLD::ComputeLoadOffset() {
+  addr_t virt_entry;
 
-    if (m_load_offset != LLDB_INVALID_ADDRESS)
-        return m_load_offset;
+  if (m_load_offset != LLDB_INVALID_ADDRESS)
+    return m_load_offset;
 
-    if ((virt_entry = GetEntryPoint()) == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
+  if ((virt_entry = GetEntryPoint()) == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
 
-    ModuleSP module = m_process->GetTarget().GetExecutableModule();
-    if (!module)
-        return LLDB_INVALID_ADDRESS;
+  ModuleSP module = m_process->GetTarget().GetExecutableModule();
+  if (!module)
+    return LLDB_INVALID_ADDRESS;
 
-    ObjectFile *exe = module->GetObjectFile();
-    if (!exe)
-        return LLDB_INVALID_ADDRESS;
+  ObjectFile *exe = module->GetObjectFile();
+  if (!exe)
+    return LLDB_INVALID_ADDRESS;
 
-    Address file_entry = exe->GetEntryPointAddress();
+  Address file_entry = exe->GetEntryPointAddress();
 
-    if (!file_entry.IsValid())
-        return LLDB_INVALID_ADDRESS;
-            
-    m_load_offset = virt_entry - file_entry.GetFileAddress();
-    return m_load_offset;
-}
+  if (!file_entry.IsValid())
+    return LLDB_INVALID_ADDRESS;
 
-void
-DynamicLoaderPOSIXDYLD::EvalVdsoStatus()
-{
-    AuxVector::iterator I = m_auxv->FindEntry(AuxVector::AT_SYSINFO_EHDR);
+  m_load_offset = virt_entry - file_entry.GetFileAddress();
+  return m_load_offset;
+}
 
-    if (I != m_auxv->end())
-        m_vdso_base = I->value;
+void DynamicLoaderPOSIXDYLD::EvalVdsoStatus() {
+  AuxVector::iterator I = m_auxv->FindEntry(AuxVector::AT_SYSINFO_EHDR);
 
+  if (I != m_auxv->end())
+    m_vdso_base = I->value;
 }
 
-addr_t
-DynamicLoaderPOSIXDYLD::GetEntryPoint()
-{
-    if (m_entry_point != LLDB_INVALID_ADDRESS)
-        return m_entry_point;
+addr_t DynamicLoaderPOSIXDYLD::GetEntryPoint() {
+  if (m_entry_point != LLDB_INVALID_ADDRESS)
+    return m_entry_point;
 
-    if (m_auxv.get() == NULL)
-        return LLDB_INVALID_ADDRESS;
+  if (m_auxv.get() == NULL)
+    return LLDB_INVALID_ADDRESS;
 
-    AuxVector::iterator I = m_auxv->FindEntry(AuxVector::AT_ENTRY);
+  AuxVector::iterator I = m_auxv->FindEntry(AuxVector::AT_ENTRY);
 
-    if (I == m_auxv->end())
-        return LLDB_INVALID_ADDRESS;
+  if (I == m_auxv->end())
+    return LLDB_INVALID_ADDRESS;
 
-    m_entry_point = static_cast<addr_t>(I->value);
+  m_entry_point = static_cast<addr_t>(I->value);
 
-    const ArchSpec &arch = m_process->GetTarget().GetArchitecture();
+  const ArchSpec &arch = m_process->GetTarget().GetArchitecture();
 
-    // On ppc64, the entry point is actually a descriptor.  Dereference it.
-    if (arch.GetMachine() == llvm::Triple::ppc64)
-        m_entry_point = ReadUnsignedIntWithSizeInBytes(m_entry_point, 8);
+  // On ppc64, the entry point is actually a descriptor.  Dereference it.
+  if (arch.GetMachine() == llvm::Triple::ppc64)
+    m_entry_point = ReadUnsignedIntWithSizeInBytes(m_entry_point, 8);
 
-    return m_entry_point;
+  return m_entry_point;
 }
 
 lldb::addr_t
-DynamicLoaderPOSIXDYLD::GetThreadLocalData(const lldb::ModuleSP module_sp, const lldb::ThreadSP thread,
-                                           lldb::addr_t tls_file_addr)
-{
-    auto it = m_loaded_modules.find (module_sp);
-    if (it == m_loaded_modules.end())
-        return LLDB_INVALID_ADDRESS;
-
-    addr_t link_map = it->second;
-    if (link_map == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-
-    const DYLDRendezvous::ThreadInfo &metadata = m_rendezvous.GetThreadInfo();
-    if (!metadata.valid)
-        return LLDB_INVALID_ADDRESS;
-
-    // Get the thread pointer.
-    addr_t tp = thread->GetThreadPointer ();
-    if (tp == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-
-    // Find the module's modid.
-    int modid_size = 4;  // FIXME(spucci): This isn't right for big-endian 64-bit
-    int64_t modid = ReadUnsignedIntWithSizeInBytes (link_map + metadata.modid_offset, modid_size);
-    if (modid == -1)
-        return LLDB_INVALID_ADDRESS;
-
-    // Lookup the DTV structure for this thread.
-    addr_t dtv_ptr = tp + metadata.dtv_offset;
-    addr_t dtv = ReadPointer (dtv_ptr);
-    if (dtv == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-
-    // Find the TLS block for this module.
-    addr_t dtv_slot = dtv + metadata.dtv_slot_size*modid;
-    addr_t tls_block = ReadPointer (dtv_slot + metadata.tls_offset);
-
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    if (log)
-        log->Printf("DynamicLoaderPOSIXDYLD::Performed TLS lookup: "
-                    "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64 ", modid=%" PRId64 ", tls_block=0x%" PRIx64 "\n",
-                    module_sp->GetObjectName().AsCString(""), link_map, tp, (int64_t)modid, tls_block);
-
-    if (tls_block == LLDB_INVALID_ADDRESS)
-        return LLDB_INVALID_ADDRESS;
-    else
-        return tls_block + tls_file_addr;
+DynamicLoaderPOSIXDYLD::GetThreadLocalData(const lldb::ModuleSP module_sp,
+                                           const lldb::ThreadSP thread,
+                                           lldb::addr_t tls_file_addr) {
+  auto it = m_loaded_modules.find(module_sp);
+  if (it == m_loaded_modules.end())
+    return LLDB_INVALID_ADDRESS;
+
+  addr_t link_map = it->second;
+  if (link_map == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+
+  const DYLDRendezvous::ThreadInfo &metadata = m_rendezvous.GetThreadInfo();
+  if (!metadata.valid)
+    return LLDB_INVALID_ADDRESS;
+
+  // Get the thread pointer.
+  addr_t tp = thread->GetThreadPointer();
+  if (tp == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+
+  // Find the module's modid.
+  int modid_size = 4; // FIXME(spucci): This isn't right for big-endian 64-bit
+  int64_t modid = ReadUnsignedIntWithSizeInBytes(
+      link_map + metadata.modid_offset, modid_size);
+  if (modid == -1)
+    return LLDB_INVALID_ADDRESS;
+
+  // Lookup the DTV structure for this thread.
+  addr_t dtv_ptr = tp + metadata.dtv_offset;
+  addr_t dtv = ReadPointer(dtv_ptr);
+  if (dtv == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+
+  // Find the TLS block for this module.
+  addr_t dtv_slot = dtv + metadata.dtv_slot_size * modid;
+  addr_t tls_block = ReadPointer(dtv_slot + metadata.tls_offset);
+
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::Performed TLS lookup: "
+                "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64
+                ", modid=%" PRId64 ", tls_block=0x%" PRIx64 "\n",
+                module_sp->GetObjectName().AsCString(""), link_map, tp,
+                (int64_t)modid, tls_block);
+
+  if (tls_block == LLDB_INVALID_ADDRESS)
+    return LLDB_INVALID_ADDRESS;
+  else
+    return tls_block + tls_file_addr;
 }
 
-void
-DynamicLoaderPOSIXDYLD::ResolveExecutableModule (lldb::ModuleSP &module_sp)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+void DynamicLoaderPOSIXDYLD::ResolveExecutableModule(
+    lldb::ModuleSP &module_sp) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-    if (m_process == nullptr)
-        return;
+  if (m_process == nullptr)
+    return;
 
-    auto &target = m_process->GetTarget ();
-    const auto platform_sp = target.GetPlatform ();
+  auto &target = m_process->GetTarget();
+  const auto platform_sp = target.GetPlatform();
 
-    ProcessInstanceInfo process_info;
-    if (!m_process->GetProcessInfo(process_info))
-    {
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s - failed to get process info for pid %" PRIu64,
-                         __FUNCTION__, m_process->GetID ());
-        return;
-    }
+  ProcessInstanceInfo process_info;
+  if (!m_process->GetProcessInfo(process_info)) {
+    if (log)
+      log->Printf("DynamicLoaderPOSIXDYLD::%s - failed to get process info for "
+                  "pid %" PRIu64,
+                  __FUNCTION__, m_process->GetID());
+    return;
+  }
+
+  if (log)
+    log->Printf("DynamicLoaderPOSIXDYLD::%s - got executable by pid %" PRIu64
+                ": %s",
+                __FUNCTION__, m_process->GetID(),
+                process_info.GetExecutableFile().GetPath().c_str());
+
+  ModuleSpec module_spec(process_info.GetExecutableFile(),
+                         process_info.GetArchitecture());
+  if (module_sp && module_sp->MatchesModuleSpec(module_spec))
+    return;
+
+  const auto executable_search_paths(Target::GetDefaultExecutableSearchPaths());
+  auto error = platform_sp->ResolveExecutable(
+      module_spec, module_sp,
+      !executable_search_paths.IsEmpty() ? &executable_search_paths : nullptr);
+  if (error.Fail()) {
+    StreamString stream;
+    module_spec.Dump(stream);
 
     if (log)
-        log->Printf ("DynamicLoaderPOSIXDYLD::%s - got executable by pid %" PRIu64 ": %s",
-                     __FUNCTION__, m_process->GetID (), process_info.GetExecutableFile ().GetPath ().c_str ());
-
-    ModuleSpec module_spec (process_info.GetExecutableFile (), process_info.GetArchitecture ());
-    if (module_sp && module_sp->MatchesModuleSpec (module_spec))
-        return;
-
-    const auto executable_search_paths (Target::GetDefaultExecutableSearchPaths());
-    auto error = platform_sp->ResolveExecutable (
-        module_spec, module_sp, !executable_search_paths.IsEmpty() ? &executable_search_paths : nullptr);
-    if (error.Fail ())
-    {
-        StreamString stream;
-        module_spec.Dump (stream);
-
-        if (log)
-            log->Printf ("DynamicLoaderPOSIXDYLD::%s - failed to resolve executable with module spec \"%s\": %s",
-                         __FUNCTION__, stream.GetString ().c_str (), error.AsCString ());
-        return;
-    }
+      log->Printf("DynamicLoaderPOSIXDYLD::%s - failed to resolve executable "
+                  "with module spec \"%s\": %s",
+                  __FUNCTION__, stream.GetData(), error.AsCString());
+    return;
+  }
+
+  target.SetExecutableModule(module_sp, false);
+}
 
-    target.SetExecutableModule (module_sp, false);
+bool DynamicLoaderPOSIXDYLD::AlwaysRelyOnEHUnwindInfo(
+    lldb_private::SymbolContext &sym_ctx) {
+  ModuleSP module_sp;
+  if (sym_ctx.symbol)
+    module_sp = sym_ctx.symbol->GetAddressRef().GetModule();
+  if (!module_sp && sym_ctx.function)
+    module_sp =
+        sym_ctx.function->GetAddressRange().GetBaseAddress().GetModule();
+  if (!module_sp)
+    return false;
+
+  return module_sp->GetFileSpec().GetPath() == "[vdso]";
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h
index 890808c..1e8333f 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h
@@ -21,159 +21,139 @@
 
 class AuxVector;
 
-class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader
-{
+class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader {
 public:
-    DynamicLoaderPOSIXDYLD(lldb_private::Process *process);
+  DynamicLoaderPOSIXDYLD(lldb_private::Process *process);
 
-    ~DynamicLoaderPOSIXDYLD() override;
+  ~DynamicLoaderPOSIXDYLD() override;
 
-    static void
-    Initialize();
+  static void Initialize();
 
-    static void
-    Terminate();
+  static void Terminate();
 
-    static lldb_private::ConstString
-    GetPluginNameStatic();
+  static lldb_private::ConstString GetPluginNameStatic();
 
-    static const char *
-    GetPluginDescriptionStatic();
+  static const char *GetPluginDescriptionStatic();
 
-    static lldb_private::DynamicLoader *
-    CreateInstance(lldb_private::Process *process, bool force);
+  static lldb_private::DynamicLoader *
+  CreateInstance(lldb_private::Process *process, bool force);
 
-    //------------------------------------------------------------------
-    // DynamicLoader protocol
-    //------------------------------------------------------------------
+  //------------------------------------------------------------------
+  // DynamicLoader protocol
+  //------------------------------------------------------------------
 
-    void
-    DidAttach() override;
+  void DidAttach() override;
 
-    void
-    DidLaunch() override;
+  void DidLaunch() override;
 
-    lldb::ThreadPlanSP
-    GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
-                                 bool stop_others) override;
+  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
+                                                  bool stop_others) override;
 
-    lldb_private::Error
-    CanLoadImage() override;
+  lldb_private::Error CanLoadImage() override;
 
-    lldb::addr_t
-    GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread, lldb::addr_t tls_file_addr) override;
+  lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
+                                  const lldb::ThreadSP thread,
+                                  lldb::addr_t tls_file_addr) override;
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
 
-    uint32_t
-    GetPluginVersion() override;
+  uint32_t GetPluginVersion() override;
 
 protected:
-    /// Runtime linker rendezvous structure.
-    DYLDRendezvous m_rendezvous;
-
-    /// Virtual load address of the inferior process.
-    lldb::addr_t m_load_offset;
-
-    /// Virtual entry address of the inferior process.
-    lldb::addr_t m_entry_point;
-
-    /// Auxiliary vector of the inferior process.
-    std::unique_ptr<AuxVector> m_auxv;
-
-    /// Rendezvous breakpoint.
-    lldb::break_id_t m_dyld_bid;
-
-    /// Contains AT_SYSINFO_EHDR, which means a vDSO has been
-    /// mapped to the address space
-    lldb::addr_t m_vdso_base;
-
-    /// Loaded module list. (link map for each module)
-    std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>> m_loaded_modules;
-
-    /// Enables a breakpoint on a function called by the runtime
-    /// linker each time a module is loaded or unloaded.
-    virtual void
-    SetRendezvousBreakpoint();
-
-    /// Callback routine which updates the current list of loaded modules based
-    /// on the information supplied by the runtime linker.
-    static bool
-    RendezvousBreakpointHit(void *baton, 
-                            lldb_private::StoppointCallbackContext *context, 
-                            lldb::user_id_t break_id, 
-                            lldb::user_id_t break_loc_id);
-    
-    /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
-    /// of loaded modules.
-    void
-    RefreshModules();
-
-    /// Updates the load address of every allocatable section in @p module.
-    ///
-    /// @param module The module to traverse.
-    ///
-    /// @param link_map_addr The virtual address of the link map for the @p module.
-    ///
-    /// @param base_addr The virtual base address @p module is loaded at.
-    void
-    UpdateLoadedSections(lldb::ModuleSP module,
-                         lldb::addr_t link_map_addr,
-                         lldb::addr_t base_addr,
-                         bool base_addr_is_offset) override;
-
-    /// Removes the loaded sections from the target in @p module.
-    ///
-    /// @param module The module to traverse.
-    void
-    UnloadSections(const lldb::ModuleSP module) override;
-
-    /// Resolves the entry point for the current inferior process and sets a
-    /// breakpoint at that address.
-    void
-    ProbeEntry();
-
-    /// Callback routine invoked when we hit the breakpoint on process entry.
-    ///
-    /// This routine is responsible for resolving the load addresses of all
-    /// dependent modules required by the inferior and setting up the rendezvous
-    /// breakpoint.
-    static bool
-    EntryBreakpointHit(void *baton, 
-                       lldb_private::StoppointCallbackContext *context, 
-                       lldb::user_id_t break_id, 
-                       lldb::user_id_t break_loc_id);
-
-    /// Helper for the entry breakpoint callback.  Resolves the load addresses
-    /// of all dependent modules.
-    virtual void
-    LoadAllCurrentModules();
-
-    /// Computes a value for m_load_offset returning the computed address on
-    /// success and LLDB_INVALID_ADDRESS on failure.
-    lldb::addr_t
-    ComputeLoadOffset();
-
-    /// Computes a value for m_entry_point returning the computed address on
-    /// success and LLDB_INVALID_ADDRESS on failure.
-    lldb::addr_t
-    GetEntryPoint();
-
-    /// Evaluate if Aux vectors contain vDSO information
-    /// in case they do, read and assign the address to m_vdso_base
-    void
-    EvalVdsoStatus();
-
-    /// Loads Module from inferior process.
-    void
-    ResolveExecutableModule(lldb::ModuleSP &module_sp);
+  /// Runtime linker rendezvous structure.
+  DYLDRendezvous m_rendezvous;
+
+  /// Virtual load address of the inferior process.
+  lldb::addr_t m_load_offset;
+
+  /// Virtual entry address of the inferior process.
+  lldb::addr_t m_entry_point;
+
+  /// Auxiliary vector of the inferior process.
+  std::unique_ptr<AuxVector> m_auxv;
+
+  /// Rendezvous breakpoint.
+  lldb::break_id_t m_dyld_bid;
+
+  /// Contains AT_SYSINFO_EHDR, which means a vDSO has been
+  /// mapped to the address space
+  lldb::addr_t m_vdso_base;
+
+  /// Loaded module list. (link map for each module)
+  std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>>
+      m_loaded_modules;
+
+  /// Enables a breakpoint on a function called by the runtime
+  /// linker each time a module is loaded or unloaded.
+  virtual void SetRendezvousBreakpoint();
+
+  /// Callback routine which updates the current list of loaded modules based
+  /// on the information supplied by the runtime linker.
+  static bool RendezvousBreakpointHit(
+      void *baton, lldb_private::StoppointCallbackContext *context,
+      lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+
+  /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
+  /// of loaded modules.
+  void RefreshModules();
+
+  /// Updates the load address of every allocatable section in @p module.
+  ///
+  /// @param module The module to traverse.
+  ///
+  /// @param link_map_addr The virtual address of the link map for the @p
+  /// module.
+  ///
+  /// @param base_addr The virtual base address @p module is loaded at.
+  void UpdateLoadedSections(lldb::ModuleSP module, lldb::addr_t link_map_addr,
+                            lldb::addr_t base_addr,
+                            bool base_addr_is_offset) override;
+
+  /// Removes the loaded sections from the target in @p module.
+  ///
+  /// @param module The module to traverse.
+  void UnloadSections(const lldb::ModuleSP module) override;
+
+  /// Resolves the entry point for the current inferior process and sets a
+  /// breakpoint at that address.
+  void ProbeEntry();
+
+  /// Callback routine invoked when we hit the breakpoint on process entry.
+  ///
+  /// This routine is responsible for resolving the load addresses of all
+  /// dependent modules required by the inferior and setting up the rendezvous
+  /// breakpoint.
+  static bool
+  EntryBreakpointHit(void *baton,
+                     lldb_private::StoppointCallbackContext *context,
+                     lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+
+  /// Helper for the entry breakpoint callback.  Resolves the load addresses
+  /// of all dependent modules.
+  virtual void LoadAllCurrentModules();
+
+  /// Computes a value for m_load_offset returning the computed address on
+  /// success and LLDB_INVALID_ADDRESS on failure.
+  lldb::addr_t ComputeLoadOffset();
+
+  /// Computes a value for m_entry_point returning the computed address on
+  /// success and LLDB_INVALID_ADDRESS on failure.
+  lldb::addr_t GetEntryPoint();
+
+  /// Evaluate if Aux vectors contain vDSO information
+  /// in case they do, read and assign the address to m_vdso_base
+  void EvalVdsoStatus();
+
+  /// Loads Module from inferior process.
+  void ResolveExecutableModule(lldb::ModuleSP &module_sp);
+
+  bool AlwaysRelyOnEHUnwindInfo(lldb_private::SymbolContext &sym_ctx) override;
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
+  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
 };
 
 #endif // liblldb_DynamicLoaderPOSIXDYLD_h_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
index daa21ad..04f1f33 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
@@ -23,50 +23,42 @@ using namespace lldb_private;
 // the plugin info class that gets handed out by the plugin factory and
 // allows the lldb to instantiate an instance of this class.
 //----------------------------------------------------------------------
-DynamicLoader *
-DynamicLoaderStatic::CreateInstance (Process* process, bool force)
-{
-    bool create = force;
-    if (!create)
-    {
-        const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
-        const llvm::Triple::OSType os_type = triple_ref.getOS();
-        if ((os_type == llvm::Triple::UnknownOS))
-            create = true;
+DynamicLoader *DynamicLoaderStatic::CreateInstance(Process *process,
+                                                   bool force) {
+  bool create = force;
+  if (!create) {
+    const llvm::Triple &triple_ref =
+        process->GetTarget().GetArchitecture().GetTriple();
+    const llvm::Triple::OSType os_type = triple_ref.getOS();
+    if ((os_type == llvm::Triple::UnknownOS))
+      create = true;
+  }
+
+  if (!create) {
+    Module *exe_module = process->GetTarget().GetExecutableModulePointer();
+    if (exe_module) {
+      ObjectFile *object_file = exe_module->GetObjectFile();
+      if (object_file) {
+        create = (object_file->GetStrata() == ObjectFile::eStrataRawImage);
+      }
     }
-    
-    if (!create)
-    {
-        Module *exe_module = process->GetTarget().GetExecutableModulePointer();
-        if (exe_module)
-        {
-            ObjectFile *object_file = exe_module->GetObjectFile();
-            if (object_file)
-            {
-                create = (object_file->GetStrata() == ObjectFile::eStrataRawImage);
-            }
-        }
-    }
-    
-    if (create)
-        return new DynamicLoaderStatic (process);
-    return NULL;
+  }
+
+  if (create)
+    return new DynamicLoaderStatic(process);
+  return NULL;
 }
 
 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
-DynamicLoaderStatic::DynamicLoaderStatic (Process* process) :
-    DynamicLoader(process)
-{
-}
+DynamicLoaderStatic::DynamicLoaderStatic(Process *process)
+    : DynamicLoader(process) {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
-DynamicLoaderStatic::~DynamicLoaderStatic()
-{
-}
+DynamicLoaderStatic::~DynamicLoaderStatic() {}
 
 //------------------------------------------------------------------
 /// Called after attaching a process.
@@ -74,11 +66,7 @@ DynamicLoaderStatic::~DynamicLoaderStatic()
 /// Allow DynamicLoader plug-ins to execute some code after
 /// attaching to a process.
 //------------------------------------------------------------------
-void
-DynamicLoaderStatic::DidAttach ()
-{
-    LoadAllImagesAtFileAddresses();
-}
+void DynamicLoaderStatic::DidAttach() { LoadAllImagesAtFileAddresses(); }
 
 //------------------------------------------------------------------
 /// Called after attaching a process.
@@ -86,124 +74,94 @@ DynamicLoaderStatic::DidAttach ()
 /// Allow DynamicLoader plug-ins to execute some code after
 /// attaching to a process.
 //------------------------------------------------------------------
-void
-DynamicLoaderStatic::DidLaunch ()
-{
-    LoadAllImagesAtFileAddresses();
-}
-
-void
-DynamicLoaderStatic::LoadAllImagesAtFileAddresses ()
-{
-    const ModuleList &module_list = m_process->GetTarget().GetImages();
-    
-    ModuleList loaded_module_list;
-
-    // Disable JIT for static dynamic loader targets
-    m_process->SetCanJIT(false);
-
-    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
-
-    const size_t num_modules = module_list.GetSize();
-    for (uint32_t idx = 0; idx < num_modules; ++idx)
-    {
-        ModuleSP module_sp (module_list.GetModuleAtIndexUnlocked (idx));
-        if (module_sp)
-        {
-            bool changed = false;
-            ObjectFile *image_object_file = module_sp->GetObjectFile();
-            if (image_object_file)
-            {
-                SectionList *section_list = image_object_file->GetSectionList ();
-                if (section_list)
-                {
-                    // All sections listed in the dyld image info structure will all
-                    // either be fixed up already, or they will all be off by a single
-                    // slide amount that is determined by finding the first segment
-                    // that is at file offset zero which also has bytes (a file size
-                    // that is greater than zero) in the object file.
-
-                    // Determine the slide amount (if any)
-                    const size_t num_sections = section_list->GetSize();
-                    size_t sect_idx = 0;
-                    for (sect_idx = 0; sect_idx < num_sections; ++sect_idx)
-                    {
-                        // Iterate through the object file sections to find the
-                        // first section that starts of file offset zero and that
-                        // has bytes in the file...
-                        SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
-                        if (section_sp)
-                        {
-                            if (m_process->GetTarget().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress()))
-                                changed = true;
-                        }
-                    }
-                }
+void DynamicLoaderStatic::DidLaunch() { LoadAllImagesAtFileAddresses(); }
+
+void DynamicLoaderStatic::LoadAllImagesAtFileAddresses() {
+  const ModuleList &module_list = m_process->GetTarget().GetImages();
+
+  ModuleList loaded_module_list;
+
+  // Disable JIT for static dynamic loader targets
+  m_process->SetCanJIT(false);
+
+  std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
+
+  const size_t num_modules = module_list.GetSize();
+  for (uint32_t idx = 0; idx < num_modules; ++idx) {
+    ModuleSP module_sp(module_list.GetModuleAtIndexUnlocked(idx));
+    if (module_sp) {
+      bool changed = false;
+      ObjectFile *image_object_file = module_sp->GetObjectFile();
+      if (image_object_file) {
+        SectionList *section_list = image_object_file->GetSectionList();
+        if (section_list) {
+          // All sections listed in the dyld image info structure will all
+          // either be fixed up already, or they will all be off by a single
+          // slide amount that is determined by finding the first segment
+          // that is at file offset zero which also has bytes (a file size
+          // that is greater than zero) in the object file.
+
+          // Determine the slide amount (if any)
+          const size_t num_sections = section_list->GetSize();
+          size_t sect_idx = 0;
+          for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
+            // Iterate through the object file sections to find the
+            // first section that starts of file offset zero and that
+            // has bytes in the file...
+            SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
+            if (section_sp) {
+              if (m_process->GetTarget().SetSectionLoadAddress(
+                      section_sp, section_sp->GetFileAddress()))
+                changed = true;
             }
-            
-            if (changed)
-                loaded_module_list.AppendIfNeeded (module_sp);
+          }
         }
+      }
+
+      if (changed)
+        loaded_module_list.AppendIfNeeded(module_sp);
     }
+  }
 
-    m_process->GetTarget().ModulesDidLoad (loaded_module_list);
+  m_process->GetTarget().ModulesDidLoad(loaded_module_list);
 }
 
 ThreadPlanSP
-DynamicLoaderStatic::GetStepThroughTrampolinePlan (Thread &thread, bool stop_others)
-{
-    return ThreadPlanSP();
+DynamicLoaderStatic::GetStepThroughTrampolinePlan(Thread &thread,
+                                                  bool stop_others) {
+  return ThreadPlanSP();
 }
 
-Error
-DynamicLoaderStatic::CanLoadImage ()
-{
-    Error error;
-    error.SetErrorString ("can't load images on with a static debug session");
-    return error;
+Error DynamicLoaderStatic::CanLoadImage() {
+  Error error;
+  error.SetErrorString("can't load images on with a static debug session");
+  return error;
 }
 
-void
-DynamicLoaderStatic::Initialize()
-{
-    PluginManager::RegisterPlugin (GetPluginNameStatic(),
-                                   GetPluginDescriptionStatic(),
-                                   CreateInstance);
+void DynamicLoaderStatic::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance);
 }
 
-void
-DynamicLoaderStatic::Terminate()
-{
-    PluginManager::UnregisterPlugin (CreateInstance);
+void DynamicLoaderStatic::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-
-lldb_private::ConstString
-DynamicLoaderStatic::GetPluginNameStatic()
-{
-    static ConstString g_name("static");
-    return g_name;
+lldb_private::ConstString DynamicLoaderStatic::GetPluginNameStatic() {
+  static ConstString g_name("static");
+  return g_name;
 }
 
-const char *
-DynamicLoaderStatic::GetPluginDescriptionStatic()
-{
-    return "Dynamic loader plug-in that will load any images at the static addresses contained in each image.";
+const char *DynamicLoaderStatic::GetPluginDescriptionStatic() {
+  return "Dynamic loader plug-in that will load any images at the static "
+         "addresses contained in each image.";
 }
 
-
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
-lldb_private::ConstString
-DynamicLoaderStatic::GetPluginName()
-{
-    return GetPluginNameStatic();
-}
-
-uint32_t
-DynamicLoaderStatic::GetPluginVersion()
-{
-    return 1;
+lldb_private::ConstString DynamicLoaderStatic::GetPluginName() {
+  return GetPluginNameStatic();
 }
 
+uint32_t DynamicLoaderStatic::GetPluginVersion() { return 1; }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h
index 67694c9..c6122edf5 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h
@@ -14,69 +14,57 @@
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Target/DynamicLoader.h"
-#include "lldb/Host/FileSpec.h"
 #include "lldb/Core/UUID.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 
-class DynamicLoaderStatic : public lldb_private::DynamicLoader
-{
+class DynamicLoaderStatic : public lldb_private::DynamicLoader {
 public:
-    DynamicLoaderStatic(lldb_private::Process *process);
+  DynamicLoaderStatic(lldb_private::Process *process);
 
-    ~DynamicLoaderStatic() override;
+  ~DynamicLoaderStatic() override;
 
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
+  //------------------------------------------------------------------
+  // Static Functions
+  //------------------------------------------------------------------
+  static void Initialize();
 
-    static void
-    Terminate();
+  static void Terminate();
 
-    static lldb_private::ConstString
-    GetPluginNameStatic();
+  static lldb_private::ConstString GetPluginNameStatic();
 
-    static const char *
-    GetPluginDescriptionStatic();
+  static const char *GetPluginDescriptionStatic();
 
-    static lldb_private::DynamicLoader *
-    CreateInstance (lldb_private::Process *process, bool force);
+  static lldb_private::DynamicLoader *
+  CreateInstance(lldb_private::Process *process, bool force);
 
-    //------------------------------------------------------------------
-    /// Called after attaching a process.
-    ///
-    /// Allow DynamicLoader plug-ins to execute some code after
-    /// attaching to a process.
-    //------------------------------------------------------------------
-    void
-    DidAttach() override;
+  //------------------------------------------------------------------
+  /// Called after attaching a process.
+  ///
+  /// Allow DynamicLoader plug-ins to execute some code after
+  /// attaching to a process.
+  //------------------------------------------------------------------
+  void DidAttach() override;
 
-    void
-    DidLaunch() override;
+  void DidLaunch() override;
 
-    lldb::ThreadPlanSP
-    GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
-                                 bool stop_others) override;
+  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
+                                                  bool stop_others) override;
 
-    lldb_private::Error
-    CanLoadImage() override;
+  lldb_private::Error CanLoadImage() override;
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
 
-    uint32_t
-    GetPluginVersion() override;
+  uint32_t GetPluginVersion() override;
 
 private:
-    void
-    LoadAllImagesAtFileAddresses ();
+  void LoadAllImagesAtFileAddresses();
 
-    DISALLOW_COPY_AND_ASSIGN (DynamicLoaderStatic);
+  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderStatic);
 };
 
 #endif // liblldb_DynamicLoaderStatic_h_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
index dd391b4..20bf360 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
@@ -1,4 +1,5 @@
-//===-- DynamicLoaderWindowsDYLD.cpp --------------------------------*- C++ -*-===//
+//===-- DynamicLoaderWindowsDYLD.cpp --------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -19,86 +20,57 @@ using namespace lldb;
 using namespace lldb_private;
 
 DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
-    : DynamicLoader(process)
-{
-}
+    : DynamicLoader(process) {}
 
-DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD()
-{
-}
+DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() {}
 
-void
-DynamicLoaderWindowsDYLD::Initialize()
-{
-    PluginManager::RegisterPlugin(GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance);
+void DynamicLoaderWindowsDYLD::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance);
 }
 
-void
-DynamicLoaderWindowsDYLD::Terminate()
-{
-}
+void DynamicLoaderWindowsDYLD::Terminate() {}
 
-ConstString
-DynamicLoaderWindowsDYLD::GetPluginNameStatic()
-{
-    static ConstString g_plugin_name("windows-dyld");
-    return g_plugin_name;
+ConstString DynamicLoaderWindowsDYLD::GetPluginNameStatic() {
+  static ConstString g_plugin_name("windows-dyld");
+  return g_plugin_name;
 }
 
-const char *
-DynamicLoaderWindowsDYLD::GetPluginDescriptionStatic()
-{
-    return "Dynamic loader plug-in that watches for shared library "
-           "loads/unloads in Windows processes.";
+const char *DynamicLoaderWindowsDYLD::GetPluginDescriptionStatic() {
+  return "Dynamic loader plug-in that watches for shared library "
+         "loads/unloads in Windows processes.";
 }
 
-DynamicLoader *
-DynamicLoaderWindowsDYLD::CreateInstance(Process *process, bool force)
-{
-    bool should_create = force;
-    if (!should_create)
-    {
-        const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
-        if (triple_ref.getOS() == llvm::Triple::Win32)
-            should_create = true;
-    }
-
-    if (should_create)
-        return new DynamicLoaderWindowsDYLD(process);
-
-    return nullptr;
-}
+DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
+                                                        bool force) {
+  bool should_create = force;
+  if (!should_create) {
+    const llvm::Triple &triple_ref =
+        process->GetTarget().GetArchitecture().GetTriple();
+    if (triple_ref.getOS() == llvm::Triple::Win32)
+      should_create = true;
+  }
 
-void
-DynamicLoaderWindowsDYLD::DidAttach()
-{
-}
+  if (should_create)
+    return new DynamicLoaderWindowsDYLD(process);
 
-void
-DynamicLoaderWindowsDYLD::DidLaunch()
-{
+  return nullptr;
 }
 
-Error
-DynamicLoaderWindowsDYLD::CanLoadImage()
-{
-    return Error();
-}
+void DynamicLoaderWindowsDYLD::DidAttach() {}
 
-ConstString
-DynamicLoaderWindowsDYLD::GetPluginName()
-{
-    return GetPluginNameStatic();
-}
+void DynamicLoaderWindowsDYLD::DidLaunch() {}
 
-uint32_t
-DynamicLoaderWindowsDYLD::GetPluginVersion()
-{
-    return 1;
+Error DynamicLoaderWindowsDYLD::CanLoadImage() { return Error(); }
+
+ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
+  return GetPluginNameStatic();
 }
 
+uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
+
 ThreadPlanSP
-DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
-{
-    return ThreadPlanSP();
+DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
+                                                       bool stop) {
+  return ThreadPlanSP();
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h
index 8c47981..3494082 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h
@@ -14,33 +14,32 @@
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/lldb-forward.h"
 #include "lldb/Target/DynamicLoader.h"
+#include "lldb/lldb-forward.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
 
-class DynamicLoaderWindowsDYLD : public DynamicLoader
-{
+class DynamicLoaderWindowsDYLD : public DynamicLoader {
 public:
-    DynamicLoaderWindowsDYLD(Process *process);
+  DynamicLoaderWindowsDYLD(Process *process);
 
-    ~DynamicLoaderWindowsDYLD() override;
+  ~DynamicLoaderWindowsDYLD() override;
 
-    static void Initialize();
-    static void Terminate();
-    static ConstString GetPluginNameStatic();
-    static const char *GetPluginDescriptionStatic();
+  static void Initialize();
+  static void Terminate();
+  static ConstString GetPluginNameStatic();
+  static const char *GetPluginDescriptionStatic();
 
-    static DynamicLoader *CreateInstance(Process *process, bool force);
+  static DynamicLoader *CreateInstance(Process *process, bool force);
 
-    void DidAttach() override;
-    void DidLaunch() override;
-    Error CanLoadImage() override;
-    lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop) override;
+  void DidAttach() override;
+  void DidLaunch() override;
+  Error CanLoadImage() override;
+  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
+                                                  bool stop) override;
 
-    ConstString GetPluginName() override;
-    uint32_t GetPluginVersion() override;
+  ConstString GetPluginName() override;
+  uint32_t GetPluginVersion() override;
 };
 
 } // namespace lldb_private