*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 958 insertions, 1089 deletions

diff --git a/lldb/source/Expression/IRExecutionUnit.cpp b/lldb/source/Expression/IRExecutionUnit.cpp
index dc4b792..3500530 100644
--- a/lldb/source/Expression/IRExecutionUnit.cpp
+++ b/lldb/source/Expression/IRExecutionUnit.cpp
@@ -21,576 +21,549 @@
 #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());
-
-    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;
-    }
-
-    if (m_did_jit)
-    {
-        func_addr = m_function_load_addr;
-        func_end = m_function_end_load_addr;
+void IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_addr,
+                                      lldb::addr_t &func_end) {
+  lldb::ProcessSP process_sp(GetProcessWP().lock());
 
-        return;
-    };
+  static std::recursive_mutex s_runnable_info_mutex;
 
-    std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex);
+  func_addr = LLDB_INVALID_ADDRESS;
+  func_end = LLDB_INVALID_ADDRESS;
 
-    m_did_jit = true;
+  if (!process_sp) {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't write the JIT compiled code into the "
+                         "process because the process is invalid");
+    return;
+  }
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
+  if (m_did_jit) {
+    func_addr = m_function_load_addr;
+    func_end = m_function_end_load_addr;
 
-    std::string error_string;
+    return;
+  };
 
-    if (log)
-    {
-        std::string s;
-        llvm::raw_string_ostream oss(s);
+  std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex);
 
-        m_module->print(oss, NULL);
+  m_did_jit = true;
 
-        oss.flush();
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-        log->Printf ("Module being sent to JIT: \n%s", s.c_str());
-    }
+  std::string error_string;
 
-    llvm::Triple triple(m_module->getTargetTriple());
-    llvm::Reloc::Model relocModel;
-    llvm::CodeModel::Model codeModel;
+  if (log) {
+    std::string s;
+    llvm::raw_string_ostream oss(s);
 
-    if (triple.isOSBinFormatELF())
-    {
-        relocModel = llvm::Reloc::Static;
-    }
-    else
-    {
-        relocModel = llvm::Reloc::PIC_;
-    }
+    m_module->print(oss, NULL);
 
-    // This will be small for 32-bit and large for 64-bit.
-    codeModel = llvm::CodeModel::JITDefault;
+    oss.flush();
 
-    m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error);
+    log->Printf("Module being sent to JIT: \n%s", s.c_str());
+  }
 
-    llvm::EngineBuilder builder(std::move(m_module_ap));
+  llvm::Triple triple(m_module->getTargetTriple());
+  llvm::Reloc::Model relocModel;
+  llvm::CodeModel::Model codeModel;
 
-    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);
+  if (triple.isOSBinFormatELF()) {
+    relocModel = llvm::Reloc::Static;
+  } else {
+    relocModel = llvm::Reloc::PIC_;
+  }
 
-    llvm::StringRef mArch;
-    llvm::StringRef mCPU;
-    llvm::SmallVector<std::string, 0> mAttrs;
+  // This will be small for 32-bit and large for 64-bit.
+  codeModel = llvm::CodeModel::JITDefault;
 
-    for (std::string &feature : m_cpu_features)
-        mAttrs.push_back(feature);
+  m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError,
+                                                          &error);
 
-    llvm::TargetMachine *target_machine = builder.selectTarget(triple,
-                                                               mArch,
-                                                               mCPU,
-                                                               mAttrs);
+  llvm::EngineBuilder builder(std::move(m_module_ap));
 
-    m_execution_engine_ap.reset(builder.create(target_machine));
+  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);
 
-    m_strip_underscore = (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_');
+  llvm::StringRef mArch;
+  llvm::StringRef mCPU;
+  llvm::SmallVector<std::string, 0> mAttrs;
 
-    if (!m_execution_engine_ap.get())
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str());
-        return;
-    }
+  for (std::string &feature : m_cpu_features)
+    mAttrs.push_back(feature);
 
-    // 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));
-    }
+  llvm::TargetMachine *target_machine =
+      builder.selectTarget(triple, mArch, mCPU, mAttrs);
 
-    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);
-    }
-    
-    for (llvm::GlobalAlias &global_alias : m_module->getAliasList())
-    {
-        RegisterOneValue(global_alias);
-    }
+  m_execution_engine_ap.reset(builder.create(target_machine));
 
-    WriteData(process_sp);
+  m_strip_underscore =
+      (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_');
 
-    if (m_failed_lookups.size())
-    {
-        StreamString ss;
+  if (!m_execution_engine_ap.get()) {
+    error.SetErrorToGenericError();
+    error.SetErrorStringWithFormat("Couldn't JIT the function: %s",
+                                   error_string.c_str());
+    return;
+  }
 
-        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.GetData());
 
-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));
@@ -614,776 +587,672 @@ 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);
+  }
 
-    return 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;
 }
 
-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();
 
-    return return_value;
+    m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
+  }
+
+  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);
+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 (demangled)
-            {
-                ConstString best_alternate_mangled_name = FindBestAlternateMangledName(demangled, lldb::eLanguageTypeC_plus_plus, sc);
+    if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
+      Mangled mangled(name, true);
+      ConstString demangled =
+          mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
 
-                if (best_alternate_mangled_name)
-                {
-                    CPP_specs.push_back(best_alternate_mangled_name);
-                }
+      if (demangled) {
+        ConstString best_alternate_mangled_name = FindBestAlternateMangledName(
+            demangled, lldb::eLanguageTypeC_plus_plus, sc);
 
-                CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull));
-            }
+        if (best_alternate_mangled_name) {
+          CPP_specs.push_back(best_alternate_mangled_name);
         }
 
-        // 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()));
-        }
+        CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull));
+      }
+    }
 
-        // 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()));
-        }
+    // 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()));
+    }
 
+    // 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()));
     }
+  }
 }
 
-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))) {
+            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;
+              }
             }
+          }
         }
+      }
     }
+  }
 }
 
 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();
 }