*** 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, 333 insertions, 420 deletions

diff --git a/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp b/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp
index a126ad0..bbb445a 100644
--- a/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp
+++ b/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp
@@ -13,10 +13,10 @@
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/DataBufferHeap.h"
-#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
@@ -35,507 +35,420 @@ using namespace lldb_private;
 //------------------------------------------------------------------
 // Debug Interface Structures
 //------------------------------------------------------------------
-typedef enum
-{
-    JIT_NOACTION = 0,
-    JIT_REGISTER_FN,
-    JIT_UNREGISTER_FN
+typedef enum {
+  JIT_NOACTION = 0,
+  JIT_REGISTER_FN,
+  JIT_UNREGISTER_FN
 } jit_actions_t;
 
-template <typename ptr_t>
-struct jit_code_entry
-{
-    ptr_t    next_entry; // pointer
-    ptr_t    prev_entry; // pointer
-    ptr_t    symfile_addr; // pointer
-    uint64_t symfile_size;
+template <typename ptr_t> struct jit_code_entry {
+  ptr_t next_entry;   // pointer
+  ptr_t prev_entry;   // pointer
+  ptr_t symfile_addr; // pointer
+  uint64_t symfile_size;
 };
 
-template <typename ptr_t>
-struct jit_descriptor
-{
-    uint32_t version;
-    uint32_t action_flag; // Values are jit_action_t
-    ptr_t    relevant_entry; // pointer
-    ptr_t    first_entry; // pointer
+template <typename ptr_t> struct jit_descriptor {
+  uint32_t version;
+  uint32_t action_flag; // Values are jit_action_t
+  ptr_t relevant_entry; // pointer
+  ptr_t first_entry;    // pointer
 };
 
 namespace {
 
-    PropertyDefinition
-    g_properties[] =
-    {
-        { "enable-jit-breakpoint", OptionValue::eTypeBoolean, true,  true , nullptr, nullptr, "Enable breakpoint on __jit_debug_register_code." },
-        {  nullptr               , OptionValue::eTypeInvalid, false, 0,     nullptr, nullptr, nullptr }
-    };
-
-    enum
-    {
-        ePropertyEnableJITBreakpoint
-    };
-
-
-    class PluginProperties : public Properties
-    {
-    public:
-        static ConstString
-        GetSettingName()
-        {
-            return JITLoaderGDB::GetPluginNameStatic();
-        }
-
-        PluginProperties()
-        {
-            m_collection_sp.reset (new OptionValueProperties(GetSettingName()));
-            m_collection_sp->Initialize(g_properties);
-        }
-
-        bool
-        GetEnableJITBreakpoint() const
-        {
-            return m_collection_sp->GetPropertyAtIndexAsBoolean(
-                nullptr,
-                ePropertyEnableJITBreakpoint,
-                g_properties[ePropertyEnableJITBreakpoint].default_uint_value != 0);
-        }
+PropertyDefinition g_properties[] = {
+    {"enable-jit-breakpoint", OptionValue::eTypeBoolean, true, true, nullptr,
+     nullptr, "Enable breakpoint on __jit_debug_register_code."},
+    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr}};
+
+enum { ePropertyEnableJITBreakpoint };
+
+class PluginProperties : public Properties {
+public:
+  static ConstString GetSettingName() {
+    return JITLoaderGDB::GetPluginNameStatic();
+  }
+
+  PluginProperties() {
+    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp->Initialize(g_properties);
+  }
+
+  bool GetEnableJITBreakpoint() const {
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(
+        nullptr, ePropertyEnableJITBreakpoint,
+        g_properties[ePropertyEnableJITBreakpoint].default_uint_value != 0);
+  }
+};
 
-    };
+typedef std::shared_ptr<PluginProperties> JITLoaderGDBPropertiesSP;
 
-    typedef std::shared_ptr<PluginProperties> JITLoaderGDBPropertiesSP;
+static const JITLoaderGDBPropertiesSP &GetGlobalPluginProperties() {
+  static const auto g_settings_sp(std::make_shared<PluginProperties>());
+  return g_settings_sp;
+}
 
-    static const JITLoaderGDBPropertiesSP&
-    GetGlobalPluginProperties()
-    {
-        static const auto g_settings_sp(std::make_shared<PluginProperties>());
-        return g_settings_sp;
-    }
+template <typename ptr_t>
+bool ReadJITEntry(const addr_t from_addr, Process *process,
+                  jit_code_entry<ptr_t> *entry) {
+  lldbassert(from_addr % sizeof(ptr_t) == 0);
+
+  ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore();
+  bool i386_target = ArchSpec::kCore_x86_32_first <= core &&
+                     core <= ArchSpec::kCore_x86_32_last;
+  uint8_t uint64_align_bytes = i386_target ? 4 : 8;
+  const size_t data_byte_size =
+      llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t);
+
+  Error error;
+  DataBufferHeap data(data_byte_size, 0);
+  size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(),
+                                          data.GetByteSize(), error);
+  if (bytes_read != data_byte_size || !error.Success())
+    return false;
+
+  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
+                          process->GetByteOrder(), sizeof(ptr_t));
+  lldb::offset_t offset = 0;
+  entry->next_entry = extractor.GetPointer(&offset);
+  entry->prev_entry = extractor.GetPointer(&offset);
+  entry->symfile_addr = extractor.GetPointer(&offset);
+  offset = llvm::alignTo(offset, uint64_align_bytes);
+  entry->symfile_size = extractor.GetU64(&offset);
+
+  return true;
+}
 
-    template <typename ptr_t>
-    bool ReadJITEntry(const addr_t from_addr, Process *process, jit_code_entry<ptr_t> *entry)
-    {
-        lldbassert(from_addr % sizeof(ptr_t) == 0);
-
-        ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore();
-        bool i386_target = ArchSpec::kCore_x86_32_first <= core && core <= ArchSpec::kCore_x86_32_last;
-        uint8_t uint64_align_bytes =  i386_target ? 4 : 8;
-        const size_t data_byte_size = llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t);
-
-        Error error;
-        DataBufferHeap data(data_byte_size, 0);
-        size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(), data.GetByteSize(), error);
-        if (bytes_read != data_byte_size || !error.Success())
-            return false;
-
-        DataExtractor extractor (data.GetBytes(), data.GetByteSize(), process->GetByteOrder(), sizeof(ptr_t));
-        lldb::offset_t offset = 0;
-        entry->next_entry = extractor.GetPointer(&offset);
-        entry->prev_entry = extractor.GetPointer(&offset);
-        entry->symfile_addr = extractor.GetPointer(&offset);
-        offset = llvm::alignTo(offset, uint64_align_bytes);
-        entry->symfile_size = extractor.GetU64(&offset);
-
-        return true;
-    }
+} // anonymous namespace end
 
-}  // anonymous namespace end
+JITLoaderGDB::JITLoaderGDB(lldb_private::Process *process)
+    : JITLoader(process), m_jit_objects(),
+      m_jit_break_id(LLDB_INVALID_BREAK_ID),
+      m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {}
 
-JITLoaderGDB::JITLoaderGDB (lldb_private::Process *process) :
-    JITLoader(process),
-    m_jit_objects(),
-    m_jit_break_id(LLDB_INVALID_BREAK_ID),
-    m_jit_descriptor_addr(LLDB_INVALID_ADDRESS)
-{
+JITLoaderGDB::~JITLoaderGDB() {
+  if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id))
+    m_process->GetTarget().RemoveBreakpointByID(m_jit_break_id);
 }
 
-JITLoaderGDB::~JITLoaderGDB ()
-{
-    if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id))
-        m_process->GetTarget().RemoveBreakpointByID (m_jit_break_id);
+void JITLoaderGDB::DebuggerInitialize(Debugger &debugger) {
+  if (!PluginManager::GetSettingForJITLoaderPlugin(
+          debugger, PluginProperties::GetSettingName())) {
+    const bool is_global_setting = true;
+    PluginManager::CreateSettingForJITLoaderPlugin(
+        debugger, GetGlobalPluginProperties()->GetValueProperties(),
+        ConstString("Properties for the JIT LoaderGDB plug-in."),
+        is_global_setting);
+  }
 }
 
-void
-JITLoaderGDB::DebuggerInitialize(Debugger &debugger)
-{
-    if (!PluginManager::GetSettingForJITLoaderPlugin(debugger, PluginProperties::GetSettingName()))
-    {
-        const bool is_global_setting = true;
-        PluginManager::CreateSettingForJITLoaderPlugin(debugger,
-                                                       GetGlobalPluginProperties()->GetValueProperties(),
-                                                       ConstString ("Properties for the JIT LoaderGDB plug-in."),
-                                                       is_global_setting);
-    }
+void JITLoaderGDB::DidAttach() {
+  Target &target = m_process->GetTarget();
+  ModuleList &module_list = target.GetImages();
+  SetJITBreakpoint(module_list);
 }
 
-void JITLoaderGDB::DidAttach()
-{
-    Target &target = m_process->GetTarget();
-    ModuleList &module_list = target.GetImages();
-    SetJITBreakpoint(module_list);
+void JITLoaderGDB::DidLaunch() {
+  Target &target = m_process->GetTarget();
+  ModuleList &module_list = target.GetImages();
+  SetJITBreakpoint(module_list);
 }
 
-void JITLoaderGDB::DidLaunch()
-{
-    Target &target = m_process->GetTarget();
-    ModuleList &module_list = target.GetImages();
+void JITLoaderGDB::ModulesDidLoad(ModuleList &module_list) {
+  if (!DidSetJITBreakpoint() && m_process->IsAlive())
     SetJITBreakpoint(module_list);
 }
 
-void
-JITLoaderGDB::ModulesDidLoad(ModuleList &module_list)
-{
-    if (!DidSetJITBreakpoint() && m_process->IsAlive())
-        SetJITBreakpoint(module_list);
-}
-
 //------------------------------------------------------------------
 // Setup the JIT Breakpoint
 //------------------------------------------------------------------
-void
-JITLoaderGDB::SetJITBreakpoint(lldb_private::ModuleList &module_list)
-{
-    if (!GetGlobalPluginProperties()->GetEnableJITBreakpoint())
-        return;
+void JITLoaderGDB::SetJITBreakpoint(lldb_private::ModuleList &module_list) {
+  if (!GetGlobalPluginProperties()->GetEnableJITBreakpoint())
+    return;
 
-    if ( DidSetJITBreakpoint() )
-        return;
+  if (DidSetJITBreakpoint())
+    return;
 
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
-    if (log)
-        log->Printf("JITLoaderGDB::%s looking for JIT register hook",
-                    __FUNCTION__);
-
-    addr_t jit_addr = GetSymbolAddress(module_list,
-                                       ConstString("__jit_debug_register_code"),
-                                       eSymbolTypeAny);
-    if (jit_addr == LLDB_INVALID_ADDRESS)
-        return;
-
-    m_jit_descriptor_addr = GetSymbolAddress(module_list,
-                                             ConstString("__jit_debug_descriptor"),
-                                             eSymbolTypeData);
-    if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
-    {
-        if (log)
-            log->Printf(
-                "JITLoaderGDB::%s failed to find JIT descriptor address",
-                __FUNCTION__);
-        return;
-    }
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
+  if (log)
+    log->Printf("JITLoaderGDB::%s looking for JIT register hook", __FUNCTION__);
+
+  addr_t jit_addr = GetSymbolAddress(
+      module_list, ConstString("__jit_debug_register_code"), eSymbolTypeAny);
+  if (jit_addr == LLDB_INVALID_ADDRESS)
+    return;
 
+  m_jit_descriptor_addr = GetSymbolAddress(
+      module_list, ConstString("__jit_debug_descriptor"), eSymbolTypeData);
+  if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) {
     if (log)
-        log->Printf("JITLoaderGDB::%s setting JIT breakpoint",
-                    __FUNCTION__);
+      log->Printf("JITLoaderGDB::%s failed to find JIT descriptor address",
+                  __FUNCTION__);
+    return;
+  }
+
+  if (log)
+    log->Printf("JITLoaderGDB::%s setting JIT breakpoint", __FUNCTION__);
 
-    Breakpoint *bp =
-        m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get();
-    bp->SetCallback(JITDebugBreakpointHit, this, true);
-    bp->SetBreakpointKind("jit-debug-register");
-    m_jit_break_id = bp->GetID();
+  Breakpoint *bp =
+      m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get();
+  bp->SetCallback(JITDebugBreakpointHit, this, true);
+  bp->SetBreakpointKind("jit-debug-register");
+  m_jit_break_id = bp->GetID();
 
-    ReadJITDescriptor(true);
+  ReadJITDescriptor(true);
 }
 
-bool
-JITLoaderGDB::JITDebugBreakpointHit(void *baton,
-                                    StoppointCallbackContext *context,
-                                    user_id_t break_id, user_id_t break_loc_id)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
-    if (log)
-        log->Printf("JITLoaderGDB::%s hit JIT breakpoint",
-                    __FUNCTION__);
-    JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton);
-    return instance->ReadJITDescriptor(false);
+bool JITLoaderGDB::JITDebugBreakpointHit(void *baton,
+                                         StoppointCallbackContext *context,
+                                         user_id_t break_id,
+                                         user_id_t break_loc_id) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
+  if (log)
+    log->Printf("JITLoaderGDB::%s hit JIT breakpoint", __FUNCTION__);
+  JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton);
+  return instance->ReadJITDescriptor(false);
 }
 
 static void updateSectionLoadAddress(const SectionList &section_list,
-                                     Target &target,
-                                     uint64_t symbolfile_addr,
+                                     Target &target, uint64_t symbolfile_addr,
                                      uint64_t symbolfile_size,
                                      uint64_t &vmaddrheuristic,
-                                     uint64_t &min_addr,
-                                     uint64_t &max_addr)
-{
-    const uint32_t num_sections = section_list.GetSize();
-    for (uint32_t i = 0; i<num_sections; ++i)
-    {
-        SectionSP section_sp(section_list.GetSectionAtIndex(i));
-        if (section_sp)
-        {
-            if(section_sp->IsFake()) {
-                uint64_t lower = (uint64_t)-1;
-                uint64_t upper = 0;
-                updateSectionLoadAddress(section_sp->GetChildren(), target, symbolfile_addr, symbolfile_size, vmaddrheuristic,
-                    lower, upper);
-                if (lower < min_addr)
-                    min_addr = lower;
-                if (upper > max_addr)
-                    max_addr = upper;
-                const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
-                section_sp->Slide(slide_amount, false);
-                section_sp->GetChildren().Slide(-slide_amount, false);
-                section_sp->SetByteSize (upper - lower);
-            } else {
-                vmaddrheuristic += 2<<section_sp->GetLog2Align();
-                uint64_t lower;
-                if (section_sp->GetFileAddress() > vmaddrheuristic)
-                    lower = section_sp->GetFileAddress();
-                else {
-                    lower = symbolfile_addr+section_sp->GetFileOffset();
-                    section_sp->SetFileAddress(symbolfile_addr+section_sp->GetFileOffset());
-                }
-                target.SetSectionLoadAddress(section_sp, lower, true);
-                uint64_t upper = lower + section_sp->GetByteSize();
-                if (lower < min_addr)
-                    min_addr = lower;
-                if (upper > max_addr)
-                    max_addr = upper;
-                // This is an upper bound, but a good enough heuristic
-                vmaddrheuristic += section_sp->GetByteSize();
-            }
+                                     uint64_t &min_addr, uint64_t &max_addr) {
+  const uint32_t num_sections = section_list.GetSize();
+  for (uint32_t i = 0; i < num_sections; ++i) {
+    SectionSP section_sp(section_list.GetSectionAtIndex(i));
+    if (section_sp) {
+      if (section_sp->IsFake()) {
+        uint64_t lower = (uint64_t)-1;
+        uint64_t upper = 0;
+        updateSectionLoadAddress(section_sp->GetChildren(), target,
+                                 symbolfile_addr, symbolfile_size,
+                                 vmaddrheuristic, lower, upper);
+        if (lower < min_addr)
+          min_addr = lower;
+        if (upper > max_addr)
+          max_addr = upper;
+        const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
+        section_sp->Slide(slide_amount, false);
+        section_sp->GetChildren().Slide(-slide_amount, false);
+        section_sp->SetByteSize(upper - lower);
+      } else {
+        vmaddrheuristic += 2 << section_sp->GetLog2Align();
+        uint64_t lower;
+        if (section_sp->GetFileAddress() > vmaddrheuristic)
+          lower = section_sp->GetFileAddress();
+        else {
+          lower = symbolfile_addr + section_sp->GetFileOffset();
+          section_sp->SetFileAddress(symbolfile_addr +
+                                     section_sp->GetFileOffset());
         }
+        target.SetSectionLoadAddress(section_sp, lower, true);
+        uint64_t upper = lower + section_sp->GetByteSize();
+        if (lower < min_addr)
+          min_addr = lower;
+        if (upper > max_addr)
+          max_addr = upper;
+        // This is an upper bound, but a good enough heuristic
+        vmaddrheuristic += section_sp->GetByteSize();
+      }
     }
+  }
 }
 
-bool
-JITLoaderGDB::ReadJITDescriptor(bool all_entries)
-{
-    if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
-        return ReadJITDescriptorImpl<uint64_t>(all_entries);
-    else
-        return ReadJITDescriptorImpl<uint32_t>(all_entries);
+bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) {
+  if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
+    return ReadJITDescriptorImpl<uint64_t>(all_entries);
+  else
+    return ReadJITDescriptorImpl<uint32_t>(all_entries);
 }
 
 template <typename ptr_t>
-bool
-JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries)
-{
-    if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
-        return false;
-
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
-    Target &target = m_process->GetTarget();
-    ModuleList &module_list = target.GetImages();
-
-    jit_descriptor<ptr_t> jit_desc;
-    const size_t jit_desc_size = sizeof(jit_desc);
-    Error error;
-    size_t bytes_read = m_process->DoReadMemory(
-        m_jit_descriptor_addr, &jit_desc, jit_desc_size, error);
-    if (bytes_read != jit_desc_size || !error.Success())
-    {
-        if (log)
-            log->Printf("JITLoaderGDB::%s failed to read JIT descriptor",
-                        __FUNCTION__);
-        return false;
-    }
-
-    jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag;
-    addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry;
-    if (all_entries)
-    {
-        jit_action = JIT_REGISTER_FN;
-        jit_relevant_entry = (addr_t)jit_desc.first_entry;
-    }
-
-    while (jit_relevant_entry != 0)
-    {
-        jit_code_entry<ptr_t> jit_entry;
-        if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry))
-        {
-            if (log)
-                log->Printf(
-                    "JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64,
+bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) {
+  if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
+    return false;
+
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
+  Target &target = m_process->GetTarget();
+  ModuleList &module_list = target.GetImages();
+
+  jit_descriptor<ptr_t> jit_desc;
+  const size_t jit_desc_size = sizeof(jit_desc);
+  Error error;
+  size_t bytes_read = m_process->DoReadMemory(m_jit_descriptor_addr, &jit_desc,
+                                              jit_desc_size, error);
+  if (bytes_read != jit_desc_size || !error.Success()) {
+    if (log)
+      log->Printf("JITLoaderGDB::%s failed to read JIT descriptor",
+                  __FUNCTION__);
+    return false;
+  }
+
+  jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag;
+  addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry;
+  if (all_entries) {
+    jit_action = JIT_REGISTER_FN;
+    jit_relevant_entry = (addr_t)jit_desc.first_entry;
+  }
+
+  while (jit_relevant_entry != 0) {
+    jit_code_entry<ptr_t> jit_entry;
+    if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) {
+      if (log)
+        log->Printf("JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64,
                     __FUNCTION__, jit_relevant_entry);
-            return false;
-        }
+      return false;
+    }
 
-        const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr;
-        const size_t &symbolfile_size = (size_t)jit_entry.symfile_size;
-        ModuleSP module_sp;
+    const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr;
+    const size_t &symbolfile_size = (size_t)jit_entry.symfile_size;
+    ModuleSP module_sp;
 
-        if (jit_action == JIT_REGISTER_FN)
-        {
-            if (log)
-                log->Printf(
-                    "JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64
+    if (jit_action == JIT_REGISTER_FN) {
+      if (log)
+        log->Printf("JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64
                     " (%" PRIu64 " bytes)",
-                    __FUNCTION__, symbolfile_addr, (uint64_t) symbolfile_size);
-
-            char jit_name[64];
-            snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr);
-            module_sp = m_process->ReadModuleFromMemory(
-                FileSpec(jit_name, false), symbolfile_addr, symbolfile_size);
-
-            if (module_sp && module_sp->GetObjectFile())
-            {
-                // load the symbol table right away
-                module_sp->GetObjectFile()->GetSymtab();
-
-                m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
-                if (module_sp->GetObjectFile()->GetPluginName() == ConstString("mach-o"))
-                {
-                    ObjectFile *image_object_file = module_sp->GetObjectFile();
-                    if (image_object_file)
-                    {
-                        const SectionList *section_list = image_object_file->GetSectionList ();
-                        if (section_list)
-                        {
-                            uint64_t vmaddrheuristic = 0;
-                            uint64_t lower = (uint64_t)-1;
-                            uint64_t upper = 0;
-                            updateSectionLoadAddress(*section_list, target, symbolfile_addr, symbolfile_size,
-                                vmaddrheuristic, lower, upper);
-                        }
-                    }
-                }
-                else
-                {
-                    bool changed = false;
-                    module_sp->SetLoadAddress(target, 0, true, changed);
-                }
-
-                module_list.AppendIfNeeded(module_sp);
-
-                ModuleList module_list;
-                module_list.Append(module_sp);
-                target.ModulesDidLoad(module_list);
-            }
-            else
-            {
-                if (log)
-                    log->Printf("JITLoaderGDB::%s failed to load module for "
-                                "JIT entry at 0x%" PRIx64,
-                                __FUNCTION__, symbolfile_addr);
+                    __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size);
+
+      char jit_name[64];
+      snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr);
+      module_sp = m_process->ReadModuleFromMemory(
+          FileSpec(jit_name, false), symbolfile_addr, symbolfile_size);
+
+      if (module_sp && module_sp->GetObjectFile()) {
+        // load the symbol table right away
+        module_sp->GetObjectFile()->GetSymtab();
+
+        m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
+        if (module_sp->GetObjectFile()->GetPluginName() ==
+            ConstString("mach-o")) {
+          ObjectFile *image_object_file = module_sp->GetObjectFile();
+          if (image_object_file) {
+            const SectionList *section_list =
+                image_object_file->GetSectionList();
+            if (section_list) {
+              uint64_t vmaddrheuristic = 0;
+              uint64_t lower = (uint64_t)-1;
+              uint64_t upper = 0;
+              updateSectionLoadAddress(*section_list, target, symbolfile_addr,
+                                       symbolfile_size, vmaddrheuristic, lower,
+                                       upper);
             }
+          }
+        } else {
+          bool changed = false;
+          module_sp->SetLoadAddress(target, 0, true, changed);
         }
-        else if (jit_action == JIT_UNREGISTER_FN)
-        {
-            if (log)
-                log->Printf(
-                    "JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64,
+
+        module_list.AppendIfNeeded(module_sp);
+
+        ModuleList module_list;
+        module_list.Append(module_sp);
+        target.ModulesDidLoad(module_list);
+      } else {
+        if (log)
+          log->Printf("JITLoaderGDB::%s failed to load module for "
+                      "JIT entry at 0x%" PRIx64,
+                      __FUNCTION__, symbolfile_addr);
+      }
+    } else if (jit_action == JIT_UNREGISTER_FN) {
+      if (log)
+        log->Printf("JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64,
                     __FUNCTION__, symbolfile_addr);
 
-            JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr);
-            if (it != m_jit_objects.end())
-            {
-                module_sp = it->second;
-                ObjectFile *image_object_file = module_sp->GetObjectFile();
-                if (image_object_file)
-                {
-                    const SectionList *section_list = image_object_file->GetSectionList ();
-                    if (section_list)
-                    {
-                        const uint32_t num_sections = section_list->GetSize();
-                        for (uint32_t i = 0; i<num_sections; ++i)
-                        {
-                            SectionSP section_sp(section_list->GetSectionAtIndex(i));
-                            if (section_sp)
-                            {
-                                target.GetSectionLoadList().SetSectionUnloaded (section_sp);
-                            }
-                        }
-                    }
-                }
-                module_list.Remove(module_sp);
-                m_jit_objects.erase(it);
+      JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr);
+      if (it != m_jit_objects.end()) {
+        module_sp = it->second;
+        ObjectFile *image_object_file = module_sp->GetObjectFile();
+        if (image_object_file) {
+          const SectionList *section_list = image_object_file->GetSectionList();
+          if (section_list) {
+            const uint32_t num_sections = section_list->GetSize();
+            for (uint32_t i = 0; i < num_sections; ++i) {
+              SectionSP section_sp(section_list->GetSectionAtIndex(i));
+              if (section_sp) {
+                target.GetSectionLoadList().SetSectionUnloaded(section_sp);
+              }
             }
+          }
         }
-        else if (jit_action == JIT_NOACTION)
-        {
-            // Nothing to do
-        }
-        else
-        {
-            assert(false && "Unknown jit action");
-        }
-
-        if (all_entries)
-            jit_relevant_entry = (addr_t)jit_entry.next_entry;
-        else
-            jit_relevant_entry = 0;
+        module_list.Remove(module_sp);
+        m_jit_objects.erase(it);
+      }
+    } else if (jit_action == JIT_NOACTION) {
+      // Nothing to do
+    } else {
+      assert(false && "Unknown jit action");
     }
 
-    return false; // Continue Running.
+    if (all_entries)
+      jit_relevant_entry = (addr_t)jit_entry.next_entry;
+    else
+      jit_relevant_entry = 0;
+  }
+
+  return false; // Continue Running.
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
-lldb_private::ConstString
-JITLoaderGDB::GetPluginNameStatic()
-{
-    static ConstString g_name("gdb");
-    return g_name;
+lldb_private::ConstString JITLoaderGDB::GetPluginNameStatic() {
+  static ConstString g_name("gdb");
+  return g_name;
 }
 
-JITLoaderSP
-JITLoaderGDB::CreateInstance(Process *process, bool force)
-{
-    JITLoaderSP jit_loader_sp;
-    ArchSpec arch (process->GetTarget().GetArchitecture());
-    if (arch.GetTriple().getVendor() != llvm::Triple::Apple)
-        jit_loader_sp.reset(new JITLoaderGDB(process));
-    return jit_loader_sp;
+JITLoaderSP JITLoaderGDB::CreateInstance(Process *process, bool force) {
+  JITLoaderSP jit_loader_sp;
+  ArchSpec arch(process->GetTarget().GetArchitecture());
+  if (arch.GetTriple().getVendor() != llvm::Triple::Apple)
+    jit_loader_sp.reset(new JITLoaderGDB(process));
+  return jit_loader_sp;
 }
 
-const char *
-JITLoaderGDB::GetPluginDescriptionStatic()
-{
-    return "JIT loader plug-in that watches for JIT events using the GDB interface.";
+const char *JITLoaderGDB::GetPluginDescriptionStatic() {
+  return "JIT loader plug-in that watches for JIT events using the GDB "
+         "interface.";
 }
 
-lldb_private::ConstString
-JITLoaderGDB::GetPluginName()
-{
-    return GetPluginNameStatic();
+lldb_private::ConstString JITLoaderGDB::GetPluginName() {
+  return GetPluginNameStatic();
 }
 
-uint32_t
-JITLoaderGDB::GetPluginVersion()
-{
-    return 1;
-}
+uint32_t JITLoaderGDB::GetPluginVersion() { return 1; }
 
-void
-JITLoaderGDB::Initialize()
-{
-    PluginManager::RegisterPlugin (GetPluginNameStatic(),
-                                   GetPluginDescriptionStatic(),
-                                   CreateInstance,
-                                   DebuggerInitialize);
+void JITLoaderGDB::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance,
+                                DebuggerInitialize);
 }
 
-void
-JITLoaderGDB::Terminate()
-{
-    PluginManager::UnregisterPlugin (CreateInstance);
+void JITLoaderGDB::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-bool
-JITLoaderGDB::DidSetJITBreakpoint() const
-{
-    return LLDB_BREAK_ID_IS_VALID(m_jit_break_id);
+bool JITLoaderGDB::DidSetJITBreakpoint() const {
+  return LLDB_BREAK_ID_IS_VALID(m_jit_break_id);
 }
 
-addr_t
-JITLoaderGDB::GetSymbolAddress(ModuleList &module_list, const ConstString &name,
-                               SymbolType symbol_type) const
-{
-    SymbolContextList target_symbols;
-    Target &target = m_process->GetTarget();
+addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list,
+                                      const ConstString &name,
+                                      SymbolType symbol_type) const {
+  SymbolContextList target_symbols;
+  Target &target = m_process->GetTarget();
 
-    if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
-                                                target_symbols))
-        return LLDB_INVALID_ADDRESS;
+  if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
+                                              target_symbols))
+    return LLDB_INVALID_ADDRESS;
 
-    SymbolContext sym_ctx;
-    target_symbols.GetContextAtIndex(0, sym_ctx);
+  SymbolContext sym_ctx;
+  target_symbols.GetContextAtIndex(0, sym_ctx);
 
-    const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
-    if (!jit_descriptor_addr.IsValid())
-        return LLDB_INVALID_ADDRESS;
+  const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
+  if (!jit_descriptor_addr.IsValid())
+    return LLDB_INVALID_ADDRESS;
 
-    const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
-    return jit_addr;
+  const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
+  return jit_addr;
 }