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

1 files changed, 968 insertions, 1086 deletions

diff --git a/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp b/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp
index 103d763..f18d96b 100644
--- a/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp
+++ b/contrib/llvm/tools/lldb/source/Expression/IRExecutionUnit.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
@@ -21,575 +22,575 @@
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/SymbolFile.h"
-#include "lldb/Expression/IRExecutionUnit.h"
+#include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/Target.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 
 #include "lldb/../../source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 
 using namespace lldb_private;
 
-IRExecutionUnit::IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap,
-                                  std::unique_ptr<llvm::Module> &module_ap,
-                                  ConstString &name,
-                                  const lldb::TargetSP &target_sp,
-                                  const SymbolContext &sym_ctx,
-                                  std::vector<std::string> &cpu_features) :
-    IRMemoryMap(target_sp),
-    m_context_ap(context_ap.release()),
-    m_module_ap(module_ap.release()),
-    m_module(m_module_ap.get()),
-    m_cpu_features(cpu_features),
-    m_name(name),
-    m_sym_ctx(sym_ctx),
-    m_did_jit(false),
-    m_function_load_addr(LLDB_INVALID_ADDRESS),
-    m_function_end_load_addr(LLDB_INVALID_ADDRESS),
-    m_reported_allocations(false)
-{
-}
-
-lldb::addr_t
-IRExecutionUnit::WriteNow (const uint8_t *bytes,
-                           size_t size,
-                           Error &error)
-{
-    const bool zero_memory = false;
-    lldb::addr_t allocation_process_addr = Malloc (size,
-                                                   8,
-                                                   lldb::ePermissionsWritable | lldb::ePermissionsReadable,
-                                                   eAllocationPolicyMirror,
-                                                   zero_memory,
-                                                   error);
-
-    if (!error.Success())
-        return LLDB_INVALID_ADDRESS;
+IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_ap,
+                                 std::unique_ptr<llvm::Module> &module_ap,
+                                 ConstString &name,
+                                 const lldb::TargetSP &target_sp,
+                                 const SymbolContext &sym_ctx,
+                                 std::vector<std::string> &cpu_features)
+    : IRMemoryMap(target_sp), m_context_ap(context_ap.release()),
+      m_module_ap(module_ap.release()), m_module(m_module_ap.get()),
+      m_cpu_features(cpu_features), m_name(name), m_sym_ctx(sym_ctx),
+      m_did_jit(false), m_function_load_addr(LLDB_INVALID_ADDRESS),
+      m_function_end_load_addr(LLDB_INVALID_ADDRESS),
+      m_reported_allocations(false) {}
+
+lldb::addr_t IRExecutionUnit::WriteNow(const uint8_t *bytes, size_t size,
+                                       Error &error) {
+  const bool zero_memory = false;
+  lldb::addr_t allocation_process_addr =
+      Malloc(size, 8, lldb::ePermissionsWritable | lldb::ePermissionsReadable,
+             eAllocationPolicyMirror, zero_memory, error);
+
+  if (!error.Success())
+    return LLDB_INVALID_ADDRESS;
 
-    WriteMemory(allocation_process_addr, bytes, size, error);
+  WriteMemory(allocation_process_addr, bytes, size, error);
 
-    if (!error.Success())
-    {
-        Error err;
-        Free (allocation_process_addr, err);
+  if (!error.Success()) {
+    Error err;
+    Free(allocation_process_addr, err);
 
-        return LLDB_INVALID_ADDRESS;
-    }
+    return LLDB_INVALID_ADDRESS;
+  }
 
-    if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
-    {
-        DataBufferHeap my_buffer(size, 0);
-        Error err;
-        ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err);
+  if (Log *log =
+          lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+    DataBufferHeap my_buffer(size, 0);
+    Error err;
+    ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err);
 
-        if (err.Success())
-        {
-            DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
-            my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), allocation_process_addr, 16, DataExtractor::TypeUInt8);
-        }
+    if (err.Success()) {
+      DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(),
+                                 lldb::eByteOrderBig, 8);
+      my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(),
+                            allocation_process_addr, 16,
+                            DataExtractor::TypeUInt8);
     }
+  }
 
-    return allocation_process_addr;
+  return allocation_process_addr;
 }
 
-void
-IRExecutionUnit::FreeNow (lldb::addr_t allocation)
-{
-    if (allocation == LLDB_INVALID_ADDRESS)
-        return;
+void IRExecutionUnit::FreeNow(lldb::addr_t allocation) {
+  if (allocation == LLDB_INVALID_ADDRESS)
+    return;
 
-    Error err;
+  Error err;
 
-    Free(allocation, err);
+  Free(allocation, err);
 }
 
-Error
-IRExecutionUnit::DisassembleFunction (Stream &stream,
-                                      lldb::ProcessSP &process_wp)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+Error IRExecutionUnit::DisassembleFunction(Stream &stream,
+                                           lldb::ProcessSP &process_wp) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    ExecutionContext exe_ctx(process_wp);
+  ExecutionContext exe_ctx(process_wp);
 
-    Error ret;
+  Error ret;
 
-    ret.Clear();
+  ret.Clear();
 
-    lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
-    lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
+  lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
+  lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
 
-    for (JittedFunction &function : m_jitted_functions)
-    {
-        if (function.m_name == m_name)
-        {
-            func_local_addr = function.m_local_addr;
-            func_remote_addr = function.m_remote_addr;
-        }
+  for (JittedFunction &function : m_jitted_functions) {
+    if (function.m_name == m_name) {
+      func_local_addr = function.m_local_addr;
+      func_remote_addr = function.m_remote_addr;
     }
+  }
 
-    if (func_local_addr == LLDB_INVALID_ADDRESS)
-    {
-        ret.SetErrorToGenericError();
-        ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", m_name.AsCString());
-        return ret;
-    }
+  if (func_local_addr == LLDB_INVALID_ADDRESS) {
+    ret.SetErrorToGenericError();
+    ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly",
+                                 m_name.AsCString());
+    return ret;
+  }
 
-    if (log)
-        log->Printf("Found function, has local address 0x%" PRIx64 " and remote address 0x%" PRIx64, (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
+  if (log)
+    log->Printf("Found function, has local address 0x%" PRIx64
+                " and remote address 0x%" PRIx64,
+                (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
 
-    std::pair <lldb::addr_t, lldb::addr_t> func_range;
+  std::pair<lldb::addr_t, lldb::addr_t> func_range;
 
-    func_range = GetRemoteRangeForLocal(func_local_addr);
+  func_range = GetRemoteRangeForLocal(func_local_addr);
 
-    if (func_range.first == 0 && func_range.second == 0)
-    {
-        ret.SetErrorToGenericError();
-        ret.SetErrorStringWithFormat("Couldn't find code range for function %s", m_name.AsCString());
-        return ret;
-    }
+  if (func_range.first == 0 && func_range.second == 0) {
+    ret.SetErrorToGenericError();
+    ret.SetErrorStringWithFormat("Couldn't find code range for function %s",
+                                 m_name.AsCString());
+    return ret;
+  }
 
-    if (log)
-        log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]", func_range.first, func_range.second);
-
-    Target *target = exe_ctx.GetTargetPtr();
-    if (!target)
-    {
-        ret.SetErrorToGenericError();
-        ret.SetErrorString("Couldn't find the target");
-        return ret;
-    }
+  if (log)
+    log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]",
+                func_range.first, func_range.second);
 
-    lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
+  Target *target = exe_ctx.GetTargetPtr();
+  if (!target) {
+    ret.SetErrorToGenericError();
+    ret.SetErrorString("Couldn't find the target");
+    return ret;
+  }
 
-    Process *process = exe_ctx.GetProcessPtr();
-    Error err;
-    process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err);
+  lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
 
-    if (!err.Success())
-    {
-        ret.SetErrorToGenericError();
-        ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error"));
-        return ret;
-    }
+  Process *process = exe_ctx.GetProcessPtr();
+  Error err;
+  process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(),
+                      buffer_sp->GetByteSize(), err);
 
-    ArchSpec arch(target->GetArchitecture());
+  if (!err.Success()) {
+    ret.SetErrorToGenericError();
+    ret.SetErrorStringWithFormat("Couldn't read from process: %s",
+                                 err.AsCString("unknown error"));
+    return ret;
+  }
 
-    const char *plugin_name = NULL;
-    const char *flavor_string = NULL;
-    lldb::DisassemblerSP disassembler_sp = Disassembler::FindPlugin(arch, flavor_string, plugin_name);
+  ArchSpec arch(target->GetArchitecture());
 
-    if (!disassembler_sp)
-    {
-        ret.SetErrorToGenericError();
-        ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName());
-        return ret;
-    }
+  const char *plugin_name = NULL;
+  const char *flavor_string = NULL;
+  lldb::DisassemblerSP disassembler_sp =
+      Disassembler::FindPlugin(arch, flavor_string, plugin_name);
 
-    if (!process)
-    {
-        ret.SetErrorToGenericError();
-        ret.SetErrorString("Couldn't find the process");
-        return ret;
-    }
+  if (!disassembler_sp) {
+    ret.SetErrorToGenericError();
+    ret.SetErrorStringWithFormat(
+        "Unable to find disassembler plug-in for %s architecture.",
+        arch.GetArchitectureName());
+    return ret;
+  }
 
-    DataExtractor extractor(buffer_sp,
-                            process->GetByteOrder(),
-                            target->GetArchitecture().GetAddressByteSize());
+  if (!process) {
+    ret.SetErrorToGenericError();
+    ret.SetErrorString("Couldn't find the process");
+    return ret;
+  }
 
-    if (log)
-    {
-        log->Printf("Function data has contents:");
-        extractor.PutToLog (log,
-                            0,
-                            extractor.GetByteSize(),
-                            func_remote_addr,
-                            16,
-                            DataExtractor::TypeUInt8);
-    }
+  DataExtractor extractor(buffer_sp, process->GetByteOrder(),
+                          target->GetArchitecture().GetAddressByteSize());
 
-    disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false);
+  if (log) {
+    log->Printf("Function data has contents:");
+    extractor.PutToLog(log, 0, extractor.GetByteSize(), func_remote_addr, 16,
+                       DataExtractor::TypeUInt8);
+  }
 
-    InstructionList &instruction_list = disassembler_sp->GetInstructionList();
-    instruction_list.Dump(&stream, true, true, &exe_ctx);
-    return ret;
+  disassembler_sp->DecodeInstructions(Address(func_remote_addr), extractor, 0,
+                                      UINT32_MAX, false, false);
+
+  InstructionList &instruction_list = disassembler_sp->GetInstructionList();
+  instruction_list.Dump(&stream, true, true, &exe_ctx);
+  return ret;
 }
 
-static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie)
-{
-    Error *err = static_cast<Error*>(Context);
+static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic,
+                                 void *Context, unsigned LocCookie) {
+  Error *err = static_cast<Error *>(Context);
 
-    if (err && err->Success())
-    {
-        err->SetErrorToGenericError();
-        err->SetErrorStringWithFormat("Inline assembly error: %s", diagnostic.getMessage().str().c_str());
-    }
+  if (err && err->Success()) {
+    err->SetErrorToGenericError();
+    err->SetErrorStringWithFormat("Inline assembly error: %s",
+                                  diagnostic.getMessage().str().c_str());
+  }
 }
 
-void
-IRExecutionUnit::ReportSymbolLookupError(const ConstString &name)
-{
-    m_failed_lookups.push_back(name);
+void IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) {
+  m_failed_lookups.push_back(name);
 }
 
-void
-IRExecutionUnit::GetRunnableInfo(Error &error,
-                                 lldb::addr_t &func_addr,
-                                 lldb::addr_t &func_end)
-{
-    lldb::ProcessSP process_sp(GetProcessWP().lock());
+void IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_addr,
+                                      lldb::addr_t &func_end) {
+  lldb::ProcessSP process_sp(GetProcessWP().lock());
 
-    static std::recursive_mutex s_runnable_info_mutex;
+  static std::recursive_mutex s_runnable_info_mutex;
 
-    func_addr = LLDB_INVALID_ADDRESS;
-    func_end = LLDB_INVALID_ADDRESS;
-
-    if (!process_sp)
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't write the JIT compiled code into the process because the process is invalid");
-        return;
-    }
+  func_addr = LLDB_INVALID_ADDRESS;
+  func_end = LLDB_INVALID_ADDRESS;
 
-    if (m_did_jit)
-    {
-        func_addr = m_function_load_addr;
-        func_end = m_function_end_load_addr;
+  if (!process_sp) {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't write the JIT compiled code into the "
+                         "process because the process is invalid");
+    return;
+  }
 
-        return;
-    };
+  if (m_did_jit) {
+    func_addr = m_function_load_addr;
+    func_end = m_function_end_load_addr;
 
-    std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex);
+    return;
+  };
 
-    m_did_jit = true;
+  std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex);
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  m_did_jit = true;
 
-    std::string error_string;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (log)
-    {
-        std::string s;
-        llvm::raw_string_ostream oss(s);
+  std::string error_string;
 
-        m_module->print(oss, NULL);
+  if (log) {
+    std::string s;
+    llvm::raw_string_ostream oss(s);
 
-        oss.flush();
+    m_module->print(oss, NULL);
 
-        log->Printf ("Module being sent to JIT: \n%s", s.c_str());
-    }
+    oss.flush();
 
-    llvm::Triple triple(m_module->getTargetTriple());
-    llvm::Reloc::Model relocModel;
-    llvm::CodeModel::Model codeModel;
+    log->Printf("Module being sent to JIT: \n%s", s.c_str());
+  }
 
-    if (triple.isOSBinFormatELF())
-    {
-        relocModel = llvm::Reloc::Static;
-    }
-    else
-    {
-        relocModel = llvm::Reloc::PIC_;
-    }
+  llvm::Triple triple(m_module->getTargetTriple());
+  llvm::Reloc::Model relocModel;
+  llvm::CodeModel::Model codeModel;
 
-    // This will be small for 32-bit and large for 64-bit.
-    codeModel = llvm::CodeModel::JITDefault;
+  if (triple.isOSBinFormatELF()) {
+    relocModel = llvm::Reloc::Static;
+  } else {
+    relocModel = llvm::Reloc::PIC_;
+  }
 
-    m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error);
+  // This will be small for 32-bit and large for 64-bit.
+  codeModel = llvm::CodeModel::JITDefault;
 
-    llvm::EngineBuilder builder(std::move(m_module_ap));
+  m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError,
+                                                          &error);
 
-    builder.setEngineKind(llvm::EngineKind::JIT)
-    .setErrorStr(&error_string)
-    .setRelocationModel(relocModel)
-    .setMCJITMemoryManager(std::unique_ptr<MemoryManager>(new MemoryManager(*this)))
-    .setCodeModel(codeModel)
-    .setOptLevel(llvm::CodeGenOpt::Less);
+  llvm::EngineBuilder builder(std::move(m_module_ap));
 
-    llvm::StringRef mArch;
-    llvm::StringRef mCPU;
-    llvm::SmallVector<std::string, 0> mAttrs;
+  builder.setEngineKind(llvm::EngineKind::JIT)
+      .setErrorStr(&error_string)
+      .setRelocationModel(relocModel)
+      .setMCJITMemoryManager(
+          std::unique_ptr<MemoryManager>(new MemoryManager(*this)))
+      .setCodeModel(codeModel)
+      .setOptLevel(llvm::CodeGenOpt::Less)
+      .setUseOrcMCJITReplacement(true);
 
-    for (std::string &feature : m_cpu_features)
-        mAttrs.push_back(feature);
+  llvm::StringRef mArch;
+  llvm::StringRef mCPU;
+  llvm::SmallVector<std::string, 0> mAttrs;
 
-    llvm::TargetMachine *target_machine = builder.selectTarget(triple,
-                                                               mArch,
-                                                               mCPU,
-                                                               mAttrs);
+  for (std::string &feature : m_cpu_features)
+    mAttrs.push_back(feature);
 
-    m_execution_engine_ap.reset(builder.create(target_machine));
+  llvm::TargetMachine *target_machine =
+      builder.selectTarget(triple, mArch, mCPU, mAttrs);
 
-    m_strip_underscore = (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_');
+  m_execution_engine_ap.reset(builder.create(target_machine));
 
-    if (!m_execution_engine_ap.get())
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str());
-        return;
-    }
+  m_strip_underscore =
+      (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_');
 
-    // Make sure we see all sections, including ones that don't have relocations...
-    m_execution_engine_ap->setProcessAllSections(true);
-
-    m_execution_engine_ap->DisableLazyCompilation();
-
-    for (llvm::Function &function : *m_module)
-    {
-        if (function.isDeclaration() || function.hasPrivateLinkage())
-            continue;
-        
-        const bool external = function.hasExternalLinkage() || function.hasLinkOnceODRLinkage();
-        
-        void *fun_ptr = m_execution_engine_ap->getPointerToFunction(&function);
-        
-        if (!error.Success())
-        {
-            // We got an error through our callback!
-            return;
-        }
-        
-        if (!fun_ptr)
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", function.getName().str().c_str());
-            return;
-        }
-        m_jitted_functions.push_back (JittedFunction(function.getName().str().c_str(), external, (lldb::addr_t)fun_ptr));
+  if (!m_execution_engine_ap.get()) {
+    error.SetErrorToGenericError();
+    error.SetErrorStringWithFormat("Couldn't JIT the function: %s",
+                                   error_string.c_str());
+    return;
+  }
+
+  class ObjectDumper : public llvm::ObjectCache {
+  public:
+    void notifyObjectCompiled(const llvm::Module *module,
+                              llvm::MemoryBufferRef object) override {
+      int fd = 0;
+      llvm::SmallVector<char, 256> result_path;
+      std::string object_name_model =
+          "jit-object-" + module->getModuleIdentifier() + "-%%%.o";
+      (void)llvm::sys::fs::createUniqueFile(object_name_model, fd, result_path);
+      llvm::raw_fd_ostream fds(fd, true);
+      fds.write(object.getBufferStart(), object.getBufferSize());
     }
 
-    CommitAllocations(process_sp);
-    ReportAllocations(*m_execution_engine_ap);
-    
-    // We have to do this after calling ReportAllocations because for the MCJIT, getGlobalValueAddress
-    // will cause the JIT to perform all relocations.  That can only be done once, and has to happen
-    // after we do the remapping from local -> remote.
-    // That means we don't know the local address of the Variables, but we don't need that for anything,
-    // so that's okay.
-    
-    std::function<void (llvm::GlobalValue &)> RegisterOneValue = [this] (llvm::GlobalValue &val) {
-        if (val.hasExternalLinkage() && !val.isDeclaration())
-        {
-            uint64_t var_ptr_addr = m_execution_engine_ap->getGlobalValueAddress(val.getName().str());
-            
-            lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr);
-            
-            // This is a really unfortunae API that sometimes returns local addresses and sometimes returns remote addresses, based on whether
-            // the variable was relocated during ReportAllocations or not.
-            
-            if (remote_addr == LLDB_INVALID_ADDRESS)
-            {
-                remote_addr = var_ptr_addr;
-            }
-                
-            if (var_ptr_addr != 0)
-                m_jitted_global_variables.push_back (JittedGlobalVariable (val.getName().str().c_str(), LLDB_INVALID_ADDRESS, remote_addr));
-        }
-    };
-    
-    for (llvm::GlobalVariable &global_var : m_module->getGlobalList())
-    {
-        RegisterOneValue(global_var);
+    std::unique_ptr<llvm::MemoryBuffer>
+    getObject(const llvm::Module *module) override {
+      // Return nothing - we're just abusing the object-cache mechanism to dump
+      // objects.
+      return nullptr;
     }
-    
-    for (llvm::GlobalAlias &global_alias : m_module->getAliasList())
-    {
-        RegisterOneValue(global_alias);
-    }
-
-    WriteData(process_sp);
+  };
 
-    if (m_failed_lookups.size())
-    {
-        StreamString ss;
+  if (process_sp->GetTarget().GetEnableSaveObjects()) {
+    m_object_cache_ap = llvm::make_unique<ObjectDumper>();
+    m_execution_engine_ap->setObjectCache(m_object_cache_ap.get());
+  }
 
-        ss.PutCString("Couldn't lookup symbols:\n");
+  // Make sure we see all sections, including ones that don't have
+  // relocations...
+  m_execution_engine_ap->setProcessAllSections(true);
 
-        bool emitNewLine = false;
+  m_execution_engine_ap->DisableLazyCompilation();
 
-        for (const ConstString &failed_lookup : m_failed_lookups)
-        {
-            if (emitNewLine)
-                ss.PutCString("\n");
-            emitNewLine = true;
-            ss.PutCString("  ");
-            ss.PutCString(Mangled(failed_lookup).GetDemangledName(lldb::eLanguageTypeObjC_plus_plus).AsCString());
-        }
+  for (llvm::Function &function : *m_module) {
+    if (function.isDeclaration() || function.hasPrivateLinkage())
+      continue;
 
-        m_failed_lookups.clear();
+    const bool external =
+        function.hasExternalLinkage() || function.hasLinkOnceODRLinkage();
 
-        error.SetErrorString(ss.GetData());
+    void *fun_ptr = m_execution_engine_ap->getPointerToFunction(&function);
 
-        return;
+    if (!error.Success()) {
+      // We got an error through our callback!
+      return;
     }
 
-    m_function_load_addr = LLDB_INVALID_ADDRESS;
-    m_function_end_load_addr = LLDB_INVALID_ADDRESS;
-
-    for (JittedFunction &jitted_function : m_jitted_functions)
-    {
-        jitted_function.m_remote_addr = GetRemoteAddressForLocal (jitted_function.m_local_addr);
-
-        if (!m_name.IsEmpty() && jitted_function.m_name == m_name)
-        {
-            AddrRange func_range = GetRemoteRangeForLocal(jitted_function.m_local_addr);
-            m_function_end_load_addr = func_range.first + func_range.second;
-            m_function_load_addr = jitted_function.m_remote_addr;
-        }
+    if (!fun_ptr) {
+      error.SetErrorToGenericError();
+      error.SetErrorStringWithFormat(
+          "'%s' was in the JITted module but wasn't lowered",
+          function.getName().str().c_str());
+      return;
     }
+    m_jitted_functions.push_back(JittedFunction(
+        function.getName().str().c_str(), external, (lldb::addr_t)fun_ptr));
+  }
+
+  CommitAllocations(process_sp);
+  ReportAllocations(*m_execution_engine_ap);
+
+  // We have to do this after calling ReportAllocations because for the MCJIT,
+  // getGlobalValueAddress
+  // will cause the JIT to perform all relocations.  That can only be done once,
+  // and has to happen
+  // after we do the remapping from local -> remote.
+  // That means we don't know the local address of the Variables, but we don't
+  // need that for anything,
+  // so that's okay.
+
+  std::function<void(llvm::GlobalValue &)> RegisterOneValue = [this](
+      llvm::GlobalValue &val) {
+    if (val.hasExternalLinkage() && !val.isDeclaration()) {
+      uint64_t var_ptr_addr =
+          m_execution_engine_ap->getGlobalValueAddress(val.getName().str());
+
+      lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr);
+
+      // This is a really unfortunae API that sometimes returns local addresses
+      // and sometimes returns remote addresses, based on whether
+      // the variable was relocated during ReportAllocations or not.
+
+      if (remote_addr == LLDB_INVALID_ADDRESS) {
+        remote_addr = var_ptr_addr;
+      }
+
+      if (var_ptr_addr != 0)
+        m_jitted_global_variables.push_back(JittedGlobalVariable(
+            val.getName().str().c_str(), LLDB_INVALID_ADDRESS, remote_addr));
+    }
+  };
 
-    if (log)
-    {
-        log->Printf("Code can be run in the target.");
-
-        StreamString disassembly_stream;
+  for (llvm::GlobalVariable &global_var : m_module->getGlobalList()) {
+    RegisterOneValue(global_var);
+  }
 
-        Error err = DisassembleFunction(disassembly_stream, process_sp);
+  for (llvm::GlobalAlias &global_alias : m_module->getAliasList()) {
+    RegisterOneValue(global_alias);
+  }
 
-        if (!err.Success())
-        {
-            log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error"));
-        }
-        else
-        {
-            log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
-        }
+  WriteData(process_sp);
 
-        log->Printf("Sections: ");
-        for (AllocationRecord &record : m_records)
-        {
-            if (record.m_process_address != LLDB_INVALID_ADDRESS)
-            {
-                record.dump(log);
+  if (m_failed_lookups.size()) {
+    StreamString ss;
 
-                DataBufferHeap my_buffer(record.m_size, 0);
-                Error err;
-                ReadMemory(my_buffer.GetBytes(), record.m_process_address, record.m_size, err);
+    ss.PutCString("Couldn't lookup symbols:\n");
 
-                if (err.Success())
-                {
-                    DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
-                    my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), record.m_process_address, 16, DataExtractor::TypeUInt8);
-                }
-            }
-            else
-            {
-                record.dump(log);
+    bool emitNewLine = false;
 
-                DataExtractor my_extractor ((const void*)record.m_host_address, record.m_size, lldb::eByteOrderBig, 8);
-                my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16, DataExtractor::TypeUInt8);
-            }
-        }
+    for (const ConstString &failed_lookup : m_failed_lookups) {
+      if (emitNewLine)
+        ss.PutCString("\n");
+      emitNewLine = true;
+      ss.PutCString("  ");
+      ss.PutCString(Mangled(failed_lookup)
+                        .GetDemangledName(lldb::eLanguageTypeObjC_plus_plus)
+                        .AsCString());
     }
 
-    func_addr = m_function_load_addr;
-    func_end = m_function_end_load_addr;
+    m_failed_lookups.clear();
 
-    return;
-}
+    error.SetErrorString(ss.GetString());
 
-IRExecutionUnit::~IRExecutionUnit ()
-{
-    m_module_ap.reset();
-    m_execution_engine_ap.reset();
-    m_context_ap.reset();
-}
+    return;
+  }
 
-IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) :
-    m_default_mm_ap (new llvm::SectionMemoryManager()),
-    m_parent (parent)
-{
-}
+  m_function_load_addr = LLDB_INVALID_ADDRESS;
+  m_function_end_load_addr = LLDB_INVALID_ADDRESS;
 
-IRExecutionUnit::MemoryManager::~MemoryManager ()
-{
-}
+  for (JittedFunction &jitted_function : m_jitted_functions) {
+    jitted_function.m_remote_addr =
+        GetRemoteAddressForLocal(jitted_function.m_local_addr);
 
-lldb::SectionType
-IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind)
-{
-    lldb::SectionType sect_type = lldb::eSectionTypeCode;
-    switch (alloc_kind)
-    {
-        case AllocationKind::Stub:  sect_type = lldb::eSectionTypeCode; break;
-        case AllocationKind::Code:  sect_type = lldb::eSectionTypeCode; break;
-        case AllocationKind::Data:  sect_type = lldb::eSectionTypeData; break;
-        case AllocationKind::Global:sect_type = lldb::eSectionTypeData; break;
-        case AllocationKind::Bytes: sect_type = lldb::eSectionTypeOther; break;
+    if (!m_name.IsEmpty() && jitted_function.m_name == m_name) {
+      AddrRange func_range =
+          GetRemoteRangeForLocal(jitted_function.m_local_addr);
+      m_function_end_load_addr = func_range.first + func_range.second;
+      m_function_load_addr = jitted_function.m_remote_addr;
     }
+  }
 
-    if (!name.empty())
-    {
-        if (name.equals("__text") || name.equals(".text"))
-            sect_type = lldb::eSectionTypeCode;
-        else if (name.equals("__data") || name.equals(".data"))
-            sect_type = lldb::eSectionTypeCode;
-        else if (name.startswith("__debug_") || name.startswith(".debug_"))
-        {
-            const uint32_t name_idx = name[0] == '_' ? 8 : 7;
-            llvm::StringRef dwarf_name(name.substr(name_idx));
-            switch (dwarf_name[0])
-            {
-                case 'a':
-                    if (dwarf_name.equals("abbrev"))
-                        sect_type = lldb::eSectionTypeDWARFDebugAbbrev;
-                    else if (dwarf_name.equals("aranges"))
-                        sect_type = lldb::eSectionTypeDWARFDebugAranges;
-                    else if (dwarf_name.equals("addr"))
-                        sect_type = lldb::eSectionTypeDWARFDebugAddr;
-                    break;
+  if (log) {
+    log->Printf("Code can be run in the target.");
 
-                case 'f':
-                    if (dwarf_name.equals("frame"))
-                        sect_type = lldb::eSectionTypeDWARFDebugFrame;
-                    break;
+    StreamString disassembly_stream;
 
-                case 'i':
-                    if (dwarf_name.equals("info"))
-                        sect_type = lldb::eSectionTypeDWARFDebugInfo;
-                    break;
+    Error err = DisassembleFunction(disassembly_stream, process_sp);
 
-                case 'l':
-                    if (dwarf_name.equals("line"))
-                        sect_type = lldb::eSectionTypeDWARFDebugLine;
-                    else if (dwarf_name.equals("loc"))
-                        sect_type = lldb::eSectionTypeDWARFDebugLoc;
-                    break;
+    if (!err.Success()) {
+      log->Printf("Couldn't disassemble function : %s",
+                  err.AsCString("unknown error"));
+    } else {
+      log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
+    }
 
-                case 'm':
-                    if (dwarf_name.equals("macinfo"))
-                        sect_type = lldb::eSectionTypeDWARFDebugMacInfo;
-                    break;
+    log->Printf("Sections: ");
+    for (AllocationRecord &record : m_records) {
+      if (record.m_process_address != LLDB_INVALID_ADDRESS) {
+        record.dump(log);
 
-                case 'p':
-                    if (dwarf_name.equals("pubnames"))
-                        sect_type = lldb::eSectionTypeDWARFDebugPubNames;
-                    else if (dwarf_name.equals("pubtypes"))
-                        sect_type = lldb::eSectionTypeDWARFDebugPubTypes;
-                    break;
+        DataBufferHeap my_buffer(record.m_size, 0);
+        Error err;
+        ReadMemory(my_buffer.GetBytes(), record.m_process_address,
+                   record.m_size, err);
+
+        if (err.Success()) {
+          DataExtractor my_extractor(my_buffer.GetBytes(),
+                                     my_buffer.GetByteSize(),
+                                     lldb::eByteOrderBig, 8);
+          my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(),
+                                record.m_process_address, 16,
+                                DataExtractor::TypeUInt8);
+        }
+      } else {
+        record.dump(log);
+
+        DataExtractor my_extractor((const void *)record.m_host_address,
+                                   record.m_size, lldb::eByteOrderBig, 8);
+        my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16,
+                              DataExtractor::TypeUInt8);
+      }
+    }
+  }
 
-                case 's':
-                    if (dwarf_name.equals("str"))
-                        sect_type = lldb::eSectionTypeDWARFDebugStr;
-                    else if (dwarf_name.equals("str_offsets"))
-                        sect_type = lldb::eSectionTypeDWARFDebugStrOffsets;
-                    break;
+  func_addr = m_function_load_addr;
+  func_end = m_function_end_load_addr;
 
-                case 'r':
-                    if (dwarf_name.equals("ranges"))
-                        sect_type = lldb::eSectionTypeDWARFDebugRanges;
-                    break;
+  return;
+}
 
-                default:
-                    break;
-            }
-        }
-        else if (name.startswith("__apple_") || name.startswith(".apple_"))
-        {
+IRExecutionUnit::~IRExecutionUnit() {
+  m_module_ap.reset();
+  m_execution_engine_ap.reset();
+  m_context_ap.reset();
+}
+
+IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent)
+    : m_default_mm_ap(new llvm::SectionMemoryManager()), m_parent(parent) {}
+
+IRExecutionUnit::MemoryManager::~MemoryManager() {}
+
+lldb::SectionType IRExecutionUnit::GetSectionTypeFromSectionName(
+    const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) {
+  lldb::SectionType sect_type = lldb::eSectionTypeCode;
+  switch (alloc_kind) {
+  case AllocationKind::Stub:
+    sect_type = lldb::eSectionTypeCode;
+    break;
+  case AllocationKind::Code:
+    sect_type = lldb::eSectionTypeCode;
+    break;
+  case AllocationKind::Data:
+    sect_type = lldb::eSectionTypeData;
+    break;
+  case AllocationKind::Global:
+    sect_type = lldb::eSectionTypeData;
+    break;
+  case AllocationKind::Bytes:
+    sect_type = lldb::eSectionTypeOther;
+    break;
+  }
+
+  if (!name.empty()) {
+    if (name.equals("__text") || name.equals(".text"))
+      sect_type = lldb::eSectionTypeCode;
+    else if (name.equals("__data") || name.equals(".data"))
+      sect_type = lldb::eSectionTypeCode;
+    else if (name.startswith("__debug_") || name.startswith(".debug_")) {
+      const uint32_t name_idx = name[0] == '_' ? 8 : 7;
+      llvm::StringRef dwarf_name(name.substr(name_idx));
+      switch (dwarf_name[0]) {
+      case 'a':
+        if (dwarf_name.equals("abbrev"))
+          sect_type = lldb::eSectionTypeDWARFDebugAbbrev;
+        else if (dwarf_name.equals("aranges"))
+          sect_type = lldb::eSectionTypeDWARFDebugAranges;
+        else if (dwarf_name.equals("addr"))
+          sect_type = lldb::eSectionTypeDWARFDebugAddr;
+        break;
+
+      case 'f':
+        if (dwarf_name.equals("frame"))
+          sect_type = lldb::eSectionTypeDWARFDebugFrame;
+        break;
+
+      case 'i':
+        if (dwarf_name.equals("info"))
+          sect_type = lldb::eSectionTypeDWARFDebugInfo;
+        break;
+
+      case 'l':
+        if (dwarf_name.equals("line"))
+          sect_type = lldb::eSectionTypeDWARFDebugLine;
+        else if (dwarf_name.equals("loc"))
+          sect_type = lldb::eSectionTypeDWARFDebugLoc;
+        break;
+
+      case 'm':
+        if (dwarf_name.equals("macinfo"))
+          sect_type = lldb::eSectionTypeDWARFDebugMacInfo;
+        break;
+
+      case 'p':
+        if (dwarf_name.equals("pubnames"))
+          sect_type = lldb::eSectionTypeDWARFDebugPubNames;
+        else if (dwarf_name.equals("pubtypes"))
+          sect_type = lldb::eSectionTypeDWARFDebugPubTypes;
+        break;
+
+      case 's':
+        if (dwarf_name.equals("str"))
+          sect_type = lldb::eSectionTypeDWARFDebugStr;
+        else if (dwarf_name.equals("str_offsets"))
+          sect_type = lldb::eSectionTypeDWARFDebugStrOffsets;
+        break;
+
+      case 'r':
+        if (dwarf_name.equals("ranges"))
+          sect_type = lldb::eSectionTypeDWARFDebugRanges;
+        break;
+
+      default:
+        break;
+      }
+    } else if (name.startswith("__apple_") || name.startswith(".apple_")) {
 #if 0
             const uint32_t name_idx = name[0] == '_' ? 8 : 7;
             llvm::StringRef apple_name(name.substr(name_idx));
@@ -613,776 +614,657 @@ IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRE
                     break;
             }
 #else
-            sect_type = lldb::eSectionTypeInvalid;
+      sect_type = lldb::eSectionTypeInvalid;
 #endif
-        }
-        else if (name.equals("__objc_imageinfo"))
-            sect_type = lldb::eSectionTypeOther;
-    }
-    return sect_type;
+    } else if (name.equals("__objc_imageinfo"))
+      sect_type = lldb::eSectionTypeOther;
+  }
+  return sect_type;
 }
 
-uint8_t *
-IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size,
-                                                    unsigned Alignment,
-                                                    unsigned SectionID,
-                                                    llvm::StringRef SectionName)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+uint8_t *IRExecutionUnit::MemoryManager::allocateCodeSection(
+    uintptr_t Size, unsigned Alignment, unsigned SectionID,
+    llvm::StringRef SectionName) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    uint8_t *return_value = m_default_mm_ap->allocateCodeSection(Size, Alignment, SectionID, SectionName);
+  uint8_t *return_value = m_default_mm_ap->allocateCodeSection(
+      Size, Alignment, SectionID, SectionName);
 
-    m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
-                                                  lldb::ePermissionsReadable | lldb::ePermissionsExecutable,
-                                                  GetSectionTypeFromSectionName (SectionName, AllocationKind::Code),
-                                                  Size,
-                                                  Alignment,
-                                                  SectionID,
-                                                  SectionName.str().c_str()));
+  m_parent.m_records.push_back(AllocationRecord(
+      (uintptr_t)return_value,
+      lldb::ePermissionsReadable | lldb::ePermissionsExecutable,
+      GetSectionTypeFromSectionName(SectionName, AllocationKind::Code), Size,
+      Alignment, SectionID, SectionName.str().c_str()));
 
-    if (log)
-    {
-        log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",
-                    (uint64_t)Size, Alignment, SectionID, (void *)return_value);
-    }
-    
-    if (m_parent.m_reported_allocations)
-    {
-        Error err;
-        lldb::ProcessSP process_sp = m_parent.GetBestExecutionContextScope()->CalculateProcess();
-        
-        m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
-    }
+  if (log) {
+    log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64
+                ", Alignment=%u, SectionID=%u) = %p",
+                (uint64_t)Size, Alignment, SectionID, (void *)return_value);
+  }
+
+  if (m_parent.m_reported_allocations) {
+    Error err;
+    lldb::ProcessSP process_sp =
+        m_parent.GetBestExecutionContextScope()->CalculateProcess();
+
+    m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
+  }
 
-    return return_value;
+  return return_value;
 }
 
-uint8_t *
-IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size,
-                                                    unsigned Alignment,
-                                                    unsigned SectionID,
-                                                    llvm::StringRef SectionName,
-                                                    bool IsReadOnly)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-
-    uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly);
-
-    uint32_t permissions = lldb::ePermissionsReadable;
-    if (!IsReadOnly)
-        permissions |= lldb::ePermissionsWritable;
-    m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
-                                                  permissions,
-                                                  GetSectionTypeFromSectionName (SectionName, AllocationKind::Data),
-                                                  Size,
-                                                  Alignment,
-                                                  SectionID,
-                                                  SectionName.str().c_str()));
-    if (log)
-    {
-        log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",
-                    (uint64_t)Size, Alignment, SectionID, (void *)return_value);
-    }
-    
-    if (m_parent.m_reported_allocations)
-    {
-        Error err;
-        lldb::ProcessSP process_sp = m_parent.GetBestExecutionContextScope()->CalculateProcess();
-        
-        m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
-    }
+uint8_t *IRExecutionUnit::MemoryManager::allocateDataSection(
+    uintptr_t Size, unsigned Alignment, unsigned SectionID,
+    llvm::StringRef SectionName, bool IsReadOnly) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  uint8_t *return_value = m_default_mm_ap->allocateDataSection(
+      Size, Alignment, SectionID, SectionName, IsReadOnly);
+
+  uint32_t permissions = lldb::ePermissionsReadable;
+  if (!IsReadOnly)
+    permissions |= lldb::ePermissionsWritable;
+  m_parent.m_records.push_back(AllocationRecord(
+      (uintptr_t)return_value, permissions,
+      GetSectionTypeFromSectionName(SectionName, AllocationKind::Data), Size,
+      Alignment, SectionID, SectionName.str().c_str()));
+  if (log) {
+    log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64
+                ", Alignment=%u, SectionID=%u) = %p",
+                (uint64_t)Size, Alignment, SectionID, (void *)return_value);
+  }
+
+  if (m_parent.m_reported_allocations) {
+    Error err;
+    lldb::ProcessSP process_sp =
+        m_parent.GetBestExecutionContextScope()->CalculateProcess();
+
+    m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
+  }
 
-    return return_value;
+  return return_value;
 }
 
 static ConstString
 FindBestAlternateMangledName(const ConstString &demangled,
                              const lldb::LanguageType &lang_type,
-                             const SymbolContext &sym_ctx)
-{
-    CPlusPlusLanguage::MethodName cpp_name(demangled);
-    std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
-
-    if (!scope_qualified_name.size())
-        return ConstString();
-
-    if (!sym_ctx.module_sp)
-        return ConstString();
-
-    SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor();
-    if (!sym_vendor)
-        return ConstString();
-
-    lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile();
-    if (!sym_file)
-        return ConstString();
-
-    std::vector<ConstString> alternates;
-    sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
-
-    std::vector<ConstString> param_and_qual_matches;
-    std::vector<ConstString> param_matches;
-    for (size_t i = 0; i < alternates.size(); i++)
-    {
-        ConstString alternate_mangled_name = alternates[i];
-        Mangled mangled(alternate_mangled_name, true);
-        ConstString demangled = mangled.GetDemangledName(lang_type);
-
-        CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
-        if (!cpp_name.IsValid())
-            continue;
-
-        if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments())
-        {
-            if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
-                param_and_qual_matches.push_back(alternate_mangled_name);
-            else
-                param_matches.push_back(alternate_mangled_name);
-        }
+                             const SymbolContext &sym_ctx) {
+  CPlusPlusLanguage::MethodName cpp_name(demangled);
+  std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
+
+  if (!scope_qualified_name.size())
+    return ConstString();
+
+  if (!sym_ctx.module_sp)
+    return ConstString();
+
+  SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor();
+  if (!sym_vendor)
+    return ConstString();
+
+  lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile();
+  if (!sym_file)
+    return ConstString();
+
+  std::vector<ConstString> alternates;
+  sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
+
+  std::vector<ConstString> param_and_qual_matches;
+  std::vector<ConstString> param_matches;
+  for (size_t i = 0; i < alternates.size(); i++) {
+    ConstString alternate_mangled_name = alternates[i];
+    Mangled mangled(alternate_mangled_name, true);
+    ConstString demangled = mangled.GetDemangledName(lang_type);
+
+    CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
+    if (!cpp_name.IsValid())
+      continue;
+
+    if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
+      if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
+        param_and_qual_matches.push_back(alternate_mangled_name);
+      else
+        param_matches.push_back(alternate_mangled_name);
     }
-
-    if (param_and_qual_matches.size())
-        return param_and_qual_matches[0]; // It is assumed that there will be only one!
-    else if (param_matches.size())
-        return param_matches[0]; // Return one of them as a best match
-    else
-        return ConstString();
+  }
+
+  if (param_and_qual_matches.size())
+    return param_and_qual_matches[0]; // It is assumed that there will be only
+                                      // one!
+  else if (param_matches.size())
+    return param_matches[0]; // Return one of them as a best match
+  else
+    return ConstString();
 }
 
-struct IRExecutionUnit::SearchSpec
-{
-    ConstString name;
-    uint32_t    mask;
+struct IRExecutionUnit::SearchSpec {
+  ConstString name;
+  uint32_t mask;
 
-    SearchSpec(ConstString n, uint32_t m = lldb::eFunctionNameTypeFull) :
-        name(n),
-        mask(m)
-    {
-    }
+  SearchSpec(ConstString n, uint32_t m = lldb::eFunctionNameTypeFull)
+      : name(n), mask(m) {}
 };
 
-void
-IRExecutionUnit::CollectCandidateCNames(std::vector<IRExecutionUnit::SearchSpec> &C_specs, const ConstString &name)
-{
-    if (m_strip_underscore && name.AsCString()[0] == '_')
-        C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));
-    C_specs.push_back(SearchSpec(name));
+void IRExecutionUnit::CollectCandidateCNames(
+    std::vector<IRExecutionUnit::SearchSpec> &C_specs,
+    const ConstString &name) {
+  if (m_strip_underscore && name.AsCString()[0] == '_')
+    C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));
+  C_specs.push_back(SearchSpec(name));
 }
 
-void
-IRExecutionUnit::CollectCandidateCPlusPlusNames(std::vector<IRExecutionUnit::SearchSpec> &CPP_specs, const std::vector<SearchSpec> &C_specs, const SymbolContext &sc)
-{
-    for (const SearchSpec &C_spec : C_specs)
-    {
-        const ConstString &name = C_spec.name;
-
-        if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString()))
-        {
-            Mangled mangled(name, true);
-            ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
-
-            if (demangled)
-            {
-                ConstString best_alternate_mangled_name = FindBestAlternateMangledName(demangled, lldb::eLanguageTypeC_plus_plus, sc);
-
-                if (best_alternate_mangled_name)
-                {
-                    CPP_specs.push_back(best_alternate_mangled_name);
-                }
+void IRExecutionUnit::CollectCandidateCPlusPlusNames(
+    std::vector<IRExecutionUnit::SearchSpec> &CPP_specs,
+    const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) {
+  for (const SearchSpec &C_spec : C_specs) {
+    const ConstString &name = C_spec.name;
 
-                CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull));
-            }
-        }
+    if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
+      Mangled mangled(name, true);
+      ConstString demangled =
+          mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
 
-        // Maybe we're looking for a const symbol but the debug info told us it was const...
-        if (!strncmp(name.GetCString(), "_ZN", 3) &&
-            strncmp(name.GetCString(), "_ZNK", 4))
-        {
-            std::string fixed_scratch("_ZNK");
-            fixed_scratch.append(name.GetCString() + 3);
-            CPP_specs.push_back(ConstString(fixed_scratch.c_str()));
-        }
+      if (demangled) {
+        ConstString best_alternate_mangled_name = FindBestAlternateMangledName(
+            demangled, lldb::eLanguageTypeC_plus_plus, sc);
 
-        // Maybe we're looking for a static symbol but we thought it was global...
-        if (!strncmp(name.GetCString(), "_Z", 2) &&
-            strncmp(name.GetCString(), "_ZL", 3))
-        {
-            std::string fixed_scratch("_ZL");
-            fixed_scratch.append(name.GetCString() + 2);
-            CPP_specs.push_back(ConstString(fixed_scratch.c_str()));
+        if (best_alternate_mangled_name) {
+          CPP_specs.push_back(best_alternate_mangled_name);
         }
 
+        CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull));
+      }
     }
+
+    std::set<ConstString> alternates;
+    CPlusPlusLanguage::FindAlternateFunctionManglings(name, alternates);
+    CPP_specs.insert(CPP_specs.end(), alternates.begin(), alternates.end());
+  }
 }
 
-void
-IRExecutionUnit::CollectFallbackNames(std::vector<SearchSpec> &fallback_specs,
-                                      const std::vector<SearchSpec> &C_specs)
-{
-    // As a last-ditch fallback, try the base name for C++ names.  It's terrible,
-    // but the DWARF doesn't always encode "extern C" correctly.
-    
-    for (const SearchSpec &C_spec : C_specs)
-    {
-        const ConstString &name = C_spec.name;
-        
-        if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString()))
-        {
-            Mangled mangled_name(name);
-            ConstString demangled_name = mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
-            if (!demangled_name.IsEmpty())
-            {
-                const char *demangled_cstr = demangled_name.AsCString();
-                const char *lparen_loc = strchr(demangled_cstr, '(');
-                if (lparen_loc)
-                {
-                    llvm::StringRef base_name(demangled_cstr, lparen_loc-demangled_cstr);
-                    fallback_specs.push_back(ConstString(base_name));
-                }
-            }
+void IRExecutionUnit::CollectFallbackNames(
+    std::vector<SearchSpec> &fallback_specs,
+    const std::vector<SearchSpec> &C_specs) {
+  // As a last-ditch fallback, try the base name for C++ names.  It's terrible,
+  // but the DWARF doesn't always encode "extern C" correctly.
+
+  for (const SearchSpec &C_spec : C_specs) {
+    const ConstString &name = C_spec.name;
+
+    if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
+      Mangled mangled_name(name);
+      ConstString demangled_name =
+          mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
+      if (!demangled_name.IsEmpty()) {
+        const char *demangled_cstr = demangled_name.AsCString();
+        const char *lparen_loc = strchr(demangled_cstr, '(');
+        if (lparen_loc) {
+          llvm::StringRef base_name(demangled_cstr,
+                                    lparen_loc - demangled_cstr);
+          fallback_specs.push_back(ConstString(base_name));
         }
+      }
     }
+  }
 }
 
+lldb::addr_t IRExecutionUnit::FindInSymbols(
+    const std::vector<IRExecutionUnit::SearchSpec> &specs,
+    const lldb_private::SymbolContext &sc) {
+  Target *target = sc.target_sp.get();
 
-lldb::addr_t
-IRExecutionUnit::FindInSymbols(const std::vector<IRExecutionUnit::SearchSpec> &specs, const lldb_private::SymbolContext &sc)
-{
-    Target *target = sc.target_sp.get();
-
-    if (!target)
-    {
-        // we shouldn't be doing any symbol lookup at all without a target
-        return LLDB_INVALID_ADDRESS;
-    }
+  if (!target) {
+    // we shouldn't be doing any symbol lookup at all without a target
+    return LLDB_INVALID_ADDRESS;
+  }
 
-    for (const SearchSpec &spec : specs)
-    {
-        SymbolContextList sc_list;
+  for (const SearchSpec &spec : specs) {
+    SymbolContextList sc_list;
 
-        lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS;
+    lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS;
 
-        std::function<bool (lldb::addr_t &, SymbolContextList &, const lldb_private::SymbolContext &)> get_external_load_address =
-            [&best_internal_load_address, target](lldb::addr_t &load_address,
-                                                  SymbolContextList &sc_list,
-                                                  const lldb_private::SymbolContext &sc) -> lldb::addr_t
-        {
-            load_address = LLDB_INVALID_ADDRESS;
+    std::function<bool(lldb::addr_t &, SymbolContextList &,
+                       const lldb_private::SymbolContext &)>
+        get_external_load_address = [&best_internal_load_address, target](
+            lldb::addr_t &load_address, SymbolContextList &sc_list,
+            const lldb_private::SymbolContext &sc) -> lldb::addr_t {
+      load_address = LLDB_INVALID_ADDRESS;
 
-            for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si)
-            {
-                SymbolContext candidate_sc;
-
-                sc_list.GetContextAtIndex(si, candidate_sc);
-
-                const bool is_external = (candidate_sc.function) ||
-                                         (candidate_sc.symbol && candidate_sc.symbol->IsExternal());
-                if (candidate_sc.symbol)
-                {
-                    load_address = candidate_sc.symbol->ResolveCallableAddress(*target);
-
-                    if (load_address == LLDB_INVALID_ADDRESS)
-                    {
-                        if (target->GetProcessSP())
-                            load_address = candidate_sc.symbol->GetAddress().GetLoadAddress(target);
-                        else
-                            load_address = candidate_sc.symbol->GetAddress().GetFileAddress();
-                    }
-                }
+      for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si) {
+        SymbolContext candidate_sc;
 
-                if (load_address == LLDB_INVALID_ADDRESS && candidate_sc.function)
-                {
-                        if (target->GetProcessSP())
-                            load_address = candidate_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(target);
-                        else
-                            load_address = candidate_sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
-                }
+        sc_list.GetContextAtIndex(si, candidate_sc);
 
-                if (load_address != LLDB_INVALID_ADDRESS)
-                {
-                    if (is_external)
-                    {
-                        return true;
-                    }
-                    else if (best_internal_load_address == LLDB_INVALID_ADDRESS)
-                    {
-                        best_internal_load_address = load_address;
-                        load_address = LLDB_INVALID_ADDRESS;
-                    }
-                }
-            }
+        const bool is_external =
+            (candidate_sc.function) ||
+            (candidate_sc.symbol && candidate_sc.symbol->IsExternal());
+        if (candidate_sc.symbol) {
+          load_address = candidate_sc.symbol->ResolveCallableAddress(*target);
 
-            return false;
-        };
-
-        if (sc.module_sp)
-        {
-            sc.module_sp->FindFunctions(spec.name,
-                                        NULL,
-                                        spec.mask,
-                                        true,  // include_symbols
-                                        false, // include_inlines
-                                        true,  // append
-                                        sc_list);
+          if (load_address == LLDB_INVALID_ADDRESS) {
+            if (target->GetProcessSP())
+              load_address =
+                  candidate_sc.symbol->GetAddress().GetLoadAddress(target);
+            else
+              load_address = candidate_sc.symbol->GetAddress().GetFileAddress();
+          }
         }
 
-        lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
-
-        if (get_external_load_address(load_address, sc_list, sc))
-        {
-            return load_address;
-        }
-        else
-        {
-            sc_list.Clear();
+        if (load_address == LLDB_INVALID_ADDRESS && candidate_sc.function) {
+          if (target->GetProcessSP())
+            load_address = candidate_sc.function->GetAddressRange()
+                               .GetBaseAddress()
+                               .GetLoadAddress(target);
+          else
+            load_address = candidate_sc.function->GetAddressRange()
+                               .GetBaseAddress()
+                               .GetFileAddress();
         }
 
-        if (sc_list.GetSize() == 0 && sc.target_sp)
-        {
-            sc.target_sp->GetImages().FindFunctions(spec.name,
-                                                    spec.mask,
-                                                    true,  // include_symbols
-                                                    false, // include_inlines
-                                                    true,  // append
-                                                    sc_list);
+        if (load_address != LLDB_INVALID_ADDRESS) {
+          if (is_external) {
+            return true;
+          } else if (best_internal_load_address == LLDB_INVALID_ADDRESS) {
+            best_internal_load_address = load_address;
+            load_address = LLDB_INVALID_ADDRESS;
+          }
         }
+      }
 
-        if (get_external_load_address(load_address, sc_list, sc))
-        {
-            return load_address;
-        }
-        else
-        {
-            sc_list.Clear();
-        }
+      return false;
+    };
 
-        if (sc_list.GetSize() == 0 && sc.target_sp)
-        {
-            sc.target_sp->GetImages().FindSymbolsWithNameAndType(spec.name, lldb::eSymbolTypeAny, sc_list);
-        }
+    if (sc.module_sp) {
+      sc.module_sp->FindFunctions(spec.name, NULL, spec.mask,
+                                  true,  // include_symbols
+                                  false, // include_inlines
+                                  true,  // append
+                                  sc_list);
+    }
 
-        if (get_external_load_address(load_address, sc_list, sc))
-        {
-            return load_address;
-        }
-        // if there are any searches we try after this, add an sc_list.Clear() in an "else" clause here
+    lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
 
-        if (best_internal_load_address != LLDB_INVALID_ADDRESS)
-        {
-            return best_internal_load_address;
-        }
+    if (get_external_load_address(load_address, sc_list, sc)) {
+      return load_address;
+    } else {
+      sc_list.Clear();
     }
 
-    return LLDB_INVALID_ADDRESS;
-}
+    if (sc_list.GetSize() == 0 && sc.target_sp) {
+      sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask,
+                                              true,  // include_symbols
+                                              false, // include_inlines
+                                              true,  // append
+                                              sc_list);
+    }
 
-lldb::addr_t
-IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc)
-{
-    lldb::TargetSP target_sp = sc.target_sp;
+    if (get_external_load_address(load_address, sc_list, sc)) {
+      return load_address;
+    } else {
+      sc_list.Clear();
+    }
 
-    if (!target_sp)
-    {
-        return LLDB_INVALID_ADDRESS;
+    if (sc_list.GetSize() == 0 && sc.target_sp) {
+      sc.target_sp->GetImages().FindSymbolsWithNameAndType(
+          spec.name, lldb::eSymbolTypeAny, sc_list);
     }
 
-    lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP();
+    if (get_external_load_address(load_address, sc_list, sc)) {
+      return load_address;
+    }
+    // if there are any searches we try after this, add an sc_list.Clear() in an
+    // "else" clause here
 
-    if (!process_sp)
-    {
-        return LLDB_INVALID_ADDRESS;
+    if (best_internal_load_address != LLDB_INVALID_ADDRESS) {
+      return best_internal_load_address;
     }
+  }
 
-    ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  return LLDB_INVALID_ADDRESS;
+}
 
-    if (runtime)
-    {
-        for (const SearchSpec &spec : specs)
-        {
-            lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name);
+lldb::addr_t
+IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs,
+                                const lldb_private::SymbolContext &sc) {
+  lldb::TargetSP target_sp = sc.target_sp;
 
-            if (symbol_load_addr != LLDB_INVALID_ADDRESS)
-                return symbol_load_addr;
-        }
-    }
+  if (!target_sp) {
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP();
 
+  if (!process_sp) {
     return LLDB_INVALID_ADDRESS;
-}
+  }
 
-lldb::addr_t
-IRExecutionUnit::FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc)
-{
-    lldb::TargetSP target_sp = sc.target_sp;
-    
-    for (const SearchSpec &spec : specs)
-    {
-        lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name);
-        
-        if (symbol_load_addr != LLDB_INVALID_ADDRESS)
-            return symbol_load_addr;
+  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+
+  if (runtime) {
+    for (const SearchSpec &spec : specs) {
+      lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name);
+
+      if (symbol_load_addr != LLDB_INVALID_ADDRESS)
+        return symbol_load_addr;
     }
-    
-    return LLDB_INVALID_ADDRESS;
+  }
+
+  return LLDB_INVALID_ADDRESS;
+}
+
+lldb::addr_t IRExecutionUnit::FindInUserDefinedSymbols(
+    const std::vector<SearchSpec> &specs,
+    const lldb_private::SymbolContext &sc) {
+  lldb::TargetSP target_sp = sc.target_sp;
+
+  for (const SearchSpec &spec : specs) {
+    lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name);
+
+    if (symbol_load_addr != LLDB_INVALID_ADDRESS)
+      return symbol_load_addr;
+  }
+
+  return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t
-IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name)
-{
-    std::vector<SearchSpec> candidate_C_names;
-    std::vector<SearchSpec> candidate_CPlusPlus_names;
+IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) {
+  std::vector<SearchSpec> candidate_C_names;
+  std::vector<SearchSpec> candidate_CPlusPlus_names;
 
-    CollectCandidateCNames(candidate_C_names, name);
+  CollectCandidateCNames(candidate_C_names, name);
 
-    lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx);
-    if (ret == LLDB_INVALID_ADDRESS)
-        ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
+  lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx);
+  if (ret == LLDB_INVALID_ADDRESS)
+    ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
 
-    if (ret == LLDB_INVALID_ADDRESS)
-        ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx);
+  if (ret == LLDB_INVALID_ADDRESS)
+    ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx);
 
-    if (ret == LLDB_INVALID_ADDRESS)
-    {
-        CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names, m_sym_ctx);
-        ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx);
-    }
-    
-    if (ret == LLDB_INVALID_ADDRESS)
-    {
-        std::vector<SearchSpec> candidate_fallback_names;
+  if (ret == LLDB_INVALID_ADDRESS) {
+    CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names,
+                                   m_sym_ctx);
+    ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx);
+  }
 
-        CollectFallbackNames(candidate_fallback_names, candidate_C_names);
-        ret = FindInSymbols(candidate_fallback_names, m_sym_ctx);
-    }
+  if (ret == LLDB_INVALID_ADDRESS) {
+    std::vector<SearchSpec> candidate_fallback_names;
 
-    return ret;
+    CollectFallbackNames(candidate_fallback_names, candidate_C_names);
+    ret = FindInSymbols(candidate_fallback_names, m_sym_ctx);
+  }
+
+  return ret;
 }
 
-void
-IRExecutionUnit::GetStaticInitializers(std::vector <lldb::addr_t> &static_initializers)
-{
-    if (llvm::GlobalVariable *global_ctors = m_module->getNamedGlobal("llvm.global_ctors"))
-    {
-        if (llvm::ConstantArray *ctor_array = llvm::dyn_cast<llvm::ConstantArray>(global_ctors->getInitializer()))
-        {
-            for (llvm::Use &ctor_use : ctor_array->operands())
-            {
-                if (llvm::ConstantStruct *ctor_struct = llvm::dyn_cast<llvm::ConstantStruct>(ctor_use))
-                {
-                    lldbassert(ctor_struct->getNumOperands() == 3); // this is standardized
-                    if (llvm::Function *ctor_function = llvm::dyn_cast<llvm::Function>(ctor_struct->getOperand(1)))
-                    {
-                        ctor_function->dump();
-
-                        ConstString ctor_function_name_cs(ctor_function->getName().str());
-                        
-                        for (JittedFunction &jitted_function : m_jitted_functions)
-                        {
-                            if (ctor_function_name_cs == jitted_function.m_name)
-                            {
-                                if (jitted_function.m_remote_addr != LLDB_INVALID_ADDRESS)
-                                {
-                                    static_initializers.push_back(jitted_function.m_remote_addr);
-                                }
-                                break;
-                            }
-                        }
-                    }
+void IRExecutionUnit::GetStaticInitializers(
+    std::vector<lldb::addr_t> &static_initializers) {
+  if (llvm::GlobalVariable *global_ctors =
+          m_module->getNamedGlobal("llvm.global_ctors")) {
+    if (llvm::ConstantArray *ctor_array = llvm::dyn_cast<llvm::ConstantArray>(
+            global_ctors->getInitializer())) {
+      for (llvm::Use &ctor_use : ctor_array->operands()) {
+        if (llvm::ConstantStruct *ctor_struct =
+                llvm::dyn_cast<llvm::ConstantStruct>(ctor_use)) {
+          lldbassert(ctor_struct->getNumOperands() ==
+                     3); // this is standardized
+          if (llvm::Function *ctor_function =
+                  llvm::dyn_cast<llvm::Function>(ctor_struct->getOperand(1))) {
+            ConstString ctor_function_name_cs(ctor_function->getName().str());
+
+            for (JittedFunction &jitted_function : m_jitted_functions) {
+              if (ctor_function_name_cs == jitted_function.m_name) {
+                if (jitted_function.m_remote_addr != LLDB_INVALID_ADDRESS) {
+                  static_initializers.push_back(jitted_function.m_remote_addr);
                 }
+                break;
+              }
             }
+          }
         }
+      }
     }
+  }
 }
 
 uint64_t
-IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    ConstString name_cs(Name.c_str());
+  ConstString name_cs(Name.c_str());
 
-    lldb::addr_t ret = m_parent.FindSymbol(name_cs);
+  lldb::addr_t ret = m_parent.FindSymbol(name_cs);
 
-    if (ret == LLDB_INVALID_ADDRESS)
-    {
-        if (log)
-            log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>",
-                        Name.c_str());
+  if (ret == LLDB_INVALID_ADDRESS) {
+    if (log)
+      log->Printf(
+          "IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>",
+          Name.c_str());
 
-        m_parent.ReportSymbolLookupError(name_cs);
-        return 0xbad0bad0;
-    }
-    else
-    {
-        if (log)
-            log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
-                        Name.c_str(),
-                        ret);
-        return ret;
-    }
+    m_parent.ReportSymbolLookupError(name_cs);
+    return 0xbad0bad0;
+  } else {
+    if (log)
+      log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
+                  Name.c_str(), ret);
+    return ret;
+  }
 }
 
-void *
-IRExecutionUnit::MemoryManager::getPointerToNamedFunction(const std::string &Name,
-                                                          bool AbortOnFailure) {
-    assert (sizeof(void *) == 8);
+void *IRExecutionUnit::MemoryManager::getPointerToNamedFunction(
+    const std::string &Name, bool AbortOnFailure) {
+  assert(sizeof(void *) == 8);
 
-    return (void*)getSymbolAddress(Name);
+  return (void *)getSymbolAddress(Name);
 }
 
 lldb::addr_t
-IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+IRExecutionUnit::GetRemoteAddressForLocal(lldb::addr_t local_address) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    for (AllocationRecord &record : m_records)
-    {
-        if (local_address >= record.m_host_address &&
-            local_address < record.m_host_address + record.m_size)
-        {
-            if (record.m_process_address == LLDB_INVALID_ADDRESS)
-                return LLDB_INVALID_ADDRESS;
+  for (AllocationRecord &record : m_records) {
+    if (local_address >= record.m_host_address &&
+        local_address < record.m_host_address + record.m_size) {
+      if (record.m_process_address == LLDB_INVALID_ADDRESS)
+        return LLDB_INVALID_ADDRESS;
 
-            lldb::addr_t ret = record.m_process_address + (local_address - record.m_host_address);
+      lldb::addr_t ret =
+          record.m_process_address + (local_address - record.m_host_address);
 
-            if (log)
-            {
-                log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].",
-                            local_address,
-                            (uint64_t)record.m_host_address,
-                            (uint64_t)record.m_host_address + (uint64_t)record.m_size,
-                            ret,
-                            record.m_process_address,
-                            record.m_process_address + record.m_size);
-            }
+      if (log) {
+        log->Printf(
+            "IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64
+            " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64
+            " from [0x%" PRIx64 "..0x%" PRIx64 "].",
+            local_address, (uint64_t)record.m_host_address,
+            (uint64_t)record.m_host_address + (uint64_t)record.m_size, ret,
+            record.m_process_address, record.m_process_address + record.m_size);
+      }
 
-            return ret;
-        }
+      return ret;
     }
+  }
 
-    return LLDB_INVALID_ADDRESS;
+  return LLDB_INVALID_ADDRESS;
 }
 
 IRExecutionUnit::AddrRange
-IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address)
-{
-    for (AllocationRecord &record : m_records)
-    {
-        if (local_address >= record.m_host_address &&
-            local_address < record.m_host_address + record.m_size)
-        {
-            if (record.m_process_address == LLDB_INVALID_ADDRESS)
-                return AddrRange(0, 0);
-
-            return AddrRange(record.m_process_address, record.m_size);
-        }
+IRExecutionUnit::GetRemoteRangeForLocal(lldb::addr_t local_address) {
+  for (AllocationRecord &record : m_records) {
+    if (local_address >= record.m_host_address &&
+        local_address < record.m_host_address + record.m_size) {
+      if (record.m_process_address == LLDB_INVALID_ADDRESS)
+        return AddrRange(0, 0);
+
+      return AddrRange(record.m_process_address, record.m_size);
     }
+  }
 
-    return AddrRange (0, 0);
+  return AddrRange(0, 0);
 }
 
-bool
-IRExecutionUnit::CommitOneAllocation (lldb::ProcessSP &process_sp,
-                                      Error &error,
-                                      AllocationRecord &record)
-{
-    if (record.m_process_address != LLDB_INVALID_ADDRESS)
-    {
-        return true;
-    }
-    
-    switch (record.m_sect_type)
-    {
-        case lldb::eSectionTypeInvalid:
-        case lldb::eSectionTypeDWARFDebugAbbrev:
-        case lldb::eSectionTypeDWARFDebugAddr:
-        case lldb::eSectionTypeDWARFDebugAranges:
-        case lldb::eSectionTypeDWARFDebugFrame:
-        case lldb::eSectionTypeDWARFDebugInfo:
-        case lldb::eSectionTypeDWARFDebugLine:
-        case lldb::eSectionTypeDWARFDebugLoc:
-        case lldb::eSectionTypeDWARFDebugMacInfo:
-        case lldb::eSectionTypeDWARFDebugPubNames:
-        case lldb::eSectionTypeDWARFDebugPubTypes:
-        case lldb::eSectionTypeDWARFDebugRanges:
-        case lldb::eSectionTypeDWARFDebugStr:
-        case lldb::eSectionTypeDWARFDebugStrOffsets:
-        case lldb::eSectionTypeDWARFAppleNames:
-        case lldb::eSectionTypeDWARFAppleTypes:
-        case lldb::eSectionTypeDWARFAppleNamespaces:
-        case lldb::eSectionTypeDWARFAppleObjC:
-            error.Clear();
-            break;
-        default:
-            const bool zero_memory = false;
-            record.m_process_address = Malloc (record.m_size,
-                                               record.m_alignment,
-                                               record.m_permissions,
-                                               eAllocationPolicyProcessOnly,
-                                               zero_memory,
-                                               error);
-            break;
-    }
-    
-    return error.Success();
+bool IRExecutionUnit::CommitOneAllocation(lldb::ProcessSP &process_sp,
+                                          Error &error,
+                                          AllocationRecord &record) {
+  if (record.m_process_address != LLDB_INVALID_ADDRESS) {
+    return true;
+  }
+
+  switch (record.m_sect_type) {
+  case lldb::eSectionTypeInvalid:
+  case lldb::eSectionTypeDWARFDebugAbbrev:
+  case lldb::eSectionTypeDWARFDebugAddr:
+  case lldb::eSectionTypeDWARFDebugAranges:
+  case lldb::eSectionTypeDWARFDebugFrame:
+  case lldb::eSectionTypeDWARFDebugInfo:
+  case lldb::eSectionTypeDWARFDebugLine:
+  case lldb::eSectionTypeDWARFDebugLoc:
+  case lldb::eSectionTypeDWARFDebugMacInfo:
+  case lldb::eSectionTypeDWARFDebugPubNames:
+  case lldb::eSectionTypeDWARFDebugPubTypes:
+  case lldb::eSectionTypeDWARFDebugRanges:
+  case lldb::eSectionTypeDWARFDebugStr:
+  case lldb::eSectionTypeDWARFDebugStrOffsets:
+  case lldb::eSectionTypeDWARFAppleNames:
+  case lldb::eSectionTypeDWARFAppleTypes:
+  case lldb::eSectionTypeDWARFAppleNamespaces:
+  case lldb::eSectionTypeDWARFAppleObjC:
+    error.Clear();
+    break;
+  default:
+    const bool zero_memory = false;
+    record.m_process_address =
+        Malloc(record.m_size, record.m_alignment, record.m_permissions,
+               eAllocationPolicyProcessOnly, zero_memory, error);
+    break;
+  }
+
+  return error.Success();
 }
 
-bool
-IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp)
-{
-    bool ret = true;
+bool IRExecutionUnit::CommitAllocations(lldb::ProcessSP &process_sp) {
+  bool ret = true;
 
-    lldb_private::Error err;
+  lldb_private::Error err;
 
-    for (AllocationRecord &record : m_records)
-    {
-        ret = CommitOneAllocation(process_sp, err, record);
-        
-        if (!ret)
-        {
-            break;
-        }
-    }
+  for (AllocationRecord &record : m_records) {
+    ret = CommitOneAllocation(process_sp, err, record);
 
-    if (!ret)
-    {
-        for (AllocationRecord &record : m_records)
-        {
-            if (record.m_process_address != LLDB_INVALID_ADDRESS)
-            {
-                Free(record.m_process_address, err);
-                record.m_process_address = LLDB_INVALID_ADDRESS;
-            }
-        }
+    if (!ret) {
+      break;
+    }
+  }
+
+  if (!ret) {
+    for (AllocationRecord &record : m_records) {
+      if (record.m_process_address != LLDB_INVALID_ADDRESS) {
+        Free(record.m_process_address, err);
+        record.m_process_address = LLDB_INVALID_ADDRESS;
+      }
     }
+  }
 
-    return ret;
+  return ret;
 }
 
-void
-IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine)
-{
-    m_reported_allocations = true;
-    
-    for (AllocationRecord &record : m_records)
-    {
-        if (record.m_process_address == LLDB_INVALID_ADDRESS)
-            continue;
+void IRExecutionUnit::ReportAllocations(llvm::ExecutionEngine &engine) {
+  m_reported_allocations = true;
 
-        if (record.m_section_id == eSectionIDInvalid)
-            continue;
+  for (AllocationRecord &record : m_records) {
+    if (record.m_process_address == LLDB_INVALID_ADDRESS)
+      continue;
 
-        engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address);
-    }
+    if (record.m_section_id == eSectionIDInvalid)
+      continue;
 
-    // Trigger re-application of relocations.
-    engine.finalizeObject();
-}
+    engine.mapSectionAddress((void *)record.m_host_address,
+                             record.m_process_address);
+  }
 
-bool
-IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp)
-{
-    bool wrote_something = false;
-    for (AllocationRecord &record : m_records)
-    {
-        if (record.m_process_address != LLDB_INVALID_ADDRESS)
-        {
-            lldb_private::Error err;
-            WriteMemory (record.m_process_address, (uint8_t*)record.m_host_address, record.m_size, err);
-            if (err.Success())
-                wrote_something = true;
-        }
-    }
-    return wrote_something;
+  // Trigger re-application of relocations.
+  engine.finalizeObject();
 }
 
-void
-IRExecutionUnit::AllocationRecord::dump (Log *log)
-{
-    if (!log)
-        return;
-
-    log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)",
-                (unsigned long long)m_host_address,
-                (unsigned long long)m_size,
-                (unsigned long long)m_process_address,
-                (unsigned)m_alignment,
-                (unsigned)m_section_id,
-                m_name.c_str());
+bool IRExecutionUnit::WriteData(lldb::ProcessSP &process_sp) {
+  bool wrote_something = false;
+  for (AllocationRecord &record : m_records) {
+    if (record.m_process_address != LLDB_INVALID_ADDRESS) {
+      lldb_private::Error err;
+      WriteMemory(record.m_process_address, (uint8_t *)record.m_host_address,
+                  record.m_size, err);
+      if (err.Success())
+        wrote_something = true;
+    }
+  }
+  return wrote_something;
 }
 
+void IRExecutionUnit::AllocationRecord::dump(Log *log) {
+  if (!log)
+    return;
 
-lldb::ByteOrder
-IRExecutionUnit::GetByteOrder () const
-{
-    ExecutionContext exe_ctx (GetBestExecutionContextScope());
-    return exe_ctx.GetByteOrder();
+  log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d, name %s)",
+              (unsigned long long)m_host_address, (unsigned long long)m_size,
+              (unsigned long long)m_process_address, (unsigned)m_alignment,
+              (unsigned)m_section_id, m_name.c_str());
 }
 
-uint32_t
-IRExecutionUnit::GetAddressByteSize () const
-{
-    ExecutionContext exe_ctx (GetBestExecutionContextScope());
-    return exe_ctx.GetAddressByteSize();
+lldb::ByteOrder IRExecutionUnit::GetByteOrder() const {
+  ExecutionContext exe_ctx(GetBestExecutionContextScope());
+  return exe_ctx.GetByteOrder();
 }
 
-void
-IRExecutionUnit::PopulateSymtab (lldb_private::ObjectFile *obj_file,
-                                 lldb_private::Symtab &symtab)
-{
-    // No symbols yet...
+uint32_t IRExecutionUnit::GetAddressByteSize() const {
+  ExecutionContext exe_ctx(GetBestExecutionContextScope());
+  return exe_ctx.GetAddressByteSize();
 }
 
+void IRExecutionUnit::PopulateSymtab(lldb_private::ObjectFile *obj_file,
+                                     lldb_private::Symtab &symtab) {
+  // No symbols yet...
+}
 
-void
-IRExecutionUnit::PopulateSectionList (lldb_private::ObjectFile *obj_file,
-                                      lldb_private::SectionList &section_list)
-{
-    for (AllocationRecord &record : m_records)
-    {
-        if (record.m_size > 0)
-        {
-            lldb::SectionSP section_sp (new lldb_private::Section (obj_file->GetModule(),
-                                                                   obj_file,
-                                                                   record.m_section_id,
-                                                                   ConstString(record.m_name),
-                                                                   record.m_sect_type,
-                                                                   record.m_process_address,
-                                                                   record.m_size,
-                                                                   record.m_host_address,   // file_offset (which is the host address for the data)
-                                                                   record.m_size,           // file_size
-                                                                   0,
-                                                                   record.m_permissions));  // flags
-            section_list.AddSection (section_sp);
-        }
+void IRExecutionUnit::PopulateSectionList(
+    lldb_private::ObjectFile *obj_file,
+    lldb_private::SectionList &section_list) {
+  for (AllocationRecord &record : m_records) {
+    if (record.m_size > 0) {
+      lldb::SectionSP section_sp(new lldb_private::Section(
+          obj_file->GetModule(), obj_file, record.m_section_id,
+          ConstString(record.m_name), record.m_sect_type,
+          record.m_process_address, record.m_size,
+          record.m_host_address, // file_offset (which is the host address for
+                                 // the data)
+          record.m_size,         // file_size
+          0,
+          record.m_permissions)); // flags
+      section_list.AddSection(section_sp);
     }
+  }
 }
 
-bool
-IRExecutionUnit::GetArchitecture (lldb_private::ArchSpec &arch)
-{
-    ExecutionContext exe_ctx (GetBestExecutionContextScope());
-    Target *target = exe_ctx.GetTargetPtr();
-    if (target)
-        arch = target->GetArchitecture();
-    else
-        arch.Clear();
-    return arch.IsValid();
+bool IRExecutionUnit::GetArchitecture(lldb_private::ArchSpec &arch) {
+  ExecutionContext exe_ctx(GetBestExecutionContextScope());
+  Target *target = exe_ctx.GetTargetPtr();
+  if (target)
+    arch = target->GetArchitecture();
+  else
+    arch.Clear();
+  return arch.IsValid();
 }
 
-lldb::ModuleSP
-IRExecutionUnit::GetJITModule ()
-{
-    ExecutionContext exe_ctx (GetBestExecutionContextScope());
-    Target *target = exe_ctx.GetTargetPtr();
-    if (target)
-    {
-        lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule (std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(shared_from_this()));
-        if (jit_module_sp)
-        {
-            bool changed = false;
-            jit_module_sp->SetLoadAddress(*target, 0, true, changed);
-        }
-        return jit_module_sp;
+lldb::ModuleSP IRExecutionUnit::GetJITModule() {
+  ExecutionContext exe_ctx(GetBestExecutionContextScope());
+  Target *target = exe_ctx.GetTargetPtr();
+  if (target) {
+    lldb::ModuleSP jit_module_sp = lldb_private::Module::CreateJITModule(
+        std::static_pointer_cast<lldb_private::ObjectFileJITDelegate>(
+            shared_from_this()));
+    if (jit_module_sp) {
+      bool changed = false;
+      jit_module_sp->SetLoadAddress(*target, 0, true, changed);
     }
-    return lldb::ModuleSP();
+    return jit_module_sp;
+  }
+  return lldb::ModuleSP();
 }