[LLDB] Fix Clang-tidy modernize-use-override warnings in some files in source/Plugins; other minor fixes.

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6.

lldb/trunk/source/Plugins/JITLoader/GDB/JITLoaderGDB.h

 //===-- JITLoaderGDB.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_JITLoaderGDB_h_
 #define liblldb_JITLoaderGDB_h_
 
 // C Includes
 // C++ Includes
 #include <map>
-#include <vector>
-#include <string>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Target/JITLoader.h"
 #include "lldb/Target/Process.h"
 
 class JITLoaderGDB : public lldb_private::JITLoader
 {
 public:
+    JITLoaderGDB(lldb_private::Process *process);
+
+    ~JITLoaderGDB() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     static lldb::JITLoaderSP
     CreateInstance (lldb_private::Process *process, bool force);
 
-    JITLoaderGDB (lldb_private::Process *process);
-
     static void
     DebuggerInitialize(lldb_private::Debugger &debugger);
 
-    virtual
-    ~JITLoaderGDB ();
-
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
     //------------------------------------------------------------------
     // JITLoader interface
     //------------------------------------------------------------------
-    virtual void
-    DidAttach ();
+    void
+    DidAttach() override;
 
-    virtual void
-    DidLaunch ();
+    void
+    DidLaunch() override;
 
-    virtual void
-    ModulesDidLoad (lldb_private::ModuleList &module_list);
+    void
+    ModulesDidLoad(lldb_private::ModuleList &module_list) override;
 
 private:
     lldb::addr_t
     GetSymbolAddress(lldb_private::ModuleList &module_list,
                      const lldb_private::ConstString &name,
                      lldb::SymbolType symbol_type) const;
 
     void
private:
     typedef std::map<lldb::addr_t, const lldb::ModuleSP> JITObjectMap;
     JITObjectMap m_jit_objects;
 
     lldb::user_id_t m_jit_break_id;
     lldb::addr_t m_jit_descriptor_addr;
 
 };
 
-#endif
+#endif // liblldb_JITLoaderGDB_h_

lldb/trunk/source/Plugins/OperatingSystem/Go/OperatingSystemGo.h

-//===-- OperatingSystemGo.h ----------------------------------*- C++ -*-===//
+//===-- OperatingSystemGo.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
-//===-------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 
 #ifndef _liblldb_OperatingSystemGo_h_
 #define _liblldb_OperatingSystemGo_h_
 
-#include <iostream>
-
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Target/OperatingSystem.h"
 
 class DynamicRegisterInfo;
 
 class OperatingSystemGo : public lldb_private::OperatingSystem
 {
-  public:
+    OperatingSystemGo(lldb_private::Process *process);
+
+    ~OperatingSystemGo() override = default;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static lldb_private::OperatingSystem *CreateInstance(lldb_private::Process *process, bool force);
 
     static void Initialize();
 
     static void DebuggerInitialize(lldb_private::Debugger &debugger);
 
     static void Terminate();
 
     static lldb_private::ConstString GetPluginNameStatic();
 
     static const char *GetPluginDescriptionStatic();
 
     //------------------------------------------------------------------
-    // Class Methods
-    //------------------------------------------------------------------
-    OperatingSystemGo(lldb_private::Process *process);
-
-    virtual ~OperatingSystemGo();
-
-    //------------------------------------------------------------------
     // lldb_private::PluginInterface Methods
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString GetPluginName();
+    lldb_private::ConstString GetPluginName() override;
 
-    virtual uint32_t GetPluginVersion();
+    uint32_t GetPluginVersion() override;
 
     //------------------------------------------------------------------
     // lldb_private::OperatingSystem Methods
     //------------------------------------------------------------------
-    virtual bool UpdateThreadList(lldb_private::ThreadList &old_thread_list, lldb_private::ThreadList &real_thread_list,
-                                  lldb_private::ThreadList &new_thread_list);
+    bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
+                          lldb_private::ThreadList &real_thread_list,
+                          lldb_private::ThreadList &new_thread_list) override;
 
-    virtual void ThreadWasSelected(lldb_private::Thread *thread);
+    void ThreadWasSelected(lldb_private::Thread *thread) override;
 
-    virtual lldb::RegisterContextSP CreateRegisterContextForThread(lldb_private::Thread *thread,
-                                                                   lldb::addr_t reg_data_addr);
+    lldb::RegisterContextSP CreateRegisterContextForThread(lldb_private::Thread *thread,
+                                                           lldb::addr_t reg_data_addr) override;
 
-    virtual lldb::StopInfoSP CreateThreadStopReason(lldb_private::Thread *thread);
+    lldb::StopInfoSP CreateThreadStopReason(lldb_private::Thread *thread) override;
 
     //------------------------------------------------------------------
     // Method for lazy creation of threads on demand
     //------------------------------------------------------------------
-    virtual lldb::ThreadSP CreateThread(lldb::tid_t tid, lldb::addr_t context);
+    lldb::ThreadSP CreateThread(lldb::tid_t tid, lldb::addr_t context) override;
 
-  private:
     struct Goroutine;
 
     static lldb::ValueObjectSP FindGlobal(lldb::TargetSP target, const char *name);
 
     static lldb::TypeSP FindType(lldb::TargetSP target_sp, const char *name);
 
     bool Init(lldb_private::ThreadList &threads);
 
     Goroutine CreateGoroutineAtIndex(uint64_t idx, lldb_private::Error &err);
 
     std::unique_ptr<DynamicRegisterInfo> m_reginfo;
     lldb::ValueObjectSP m_allg_sp;
     lldb::ValueObjectSP m_allglen_sp;
 };
 
-#endif // #ifndef liblldb_OperatingSystemGo_h_
+#endif // liblldb_OperatingSystemGo_h_

lldb/trunk/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

-//===-- OperatingSystemGo.cpp --------------------------------*- C++ -*-===//
+//===-- OperatingSystemGo.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "OperatingSystemGo.h"
 
 // C Includes
 // C++ Includes
 #include <unordered_map>
 
 // Other libraries and framework includes
+// Project includes
+#include "OperatingSystemGo.h"
+
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObjectVariable.h"

 
 enum
 {
     ePropertyEnableGoroutines,
 };
 
 class PluginProperties : public Properties
 {
-  public:
-    static ConstString
-    GetSettingName()
-    {
-        return OperatingSystemGo::GetPluginNameStatic();
-    }
-
     PluginProperties()
         : Properties()
     {
         m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
         m_collection_sp->Initialize(g_properties);
     }
 
-    virtual ~PluginProperties() {}
+    ~PluginProperties() override = default;
+
+    static ConstString
+    GetSettingName()
+    {
+        return OperatingSystemGo::GetPluginNameStatic();
+    }
 
     bool
     GetEnableGoroutines()
     {
         const uint32_t idx = ePropertyEnableGoroutines;
         return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value);
     }
 
GetGlobalPluginProperties()
     static OperatingSystemGoPropertiesSP g_settings_sp;
     if (!g_settings_sp)
         g_settings_sp.reset(new PluginProperties());
     return g_settings_sp;
 }
 
 class RegisterContextGo : public RegisterContextMemory
 {
-  public:
-    //------------------------------------------------------------------
-    // Constructors and Destructors
-    //------------------------------------------------------------------
     RegisterContextGo(lldb_private::Thread &thread, uint32_t concrete_frame_idx, DynamicRegisterInfo &reg_info,
                       lldb::addr_t reg_data_addr)
         : RegisterContextMemory(thread, concrete_frame_idx, reg_info, reg_data_addr)
     {
         const RegisterInfo *sp = reg_info.GetRegisterInfoAtIndex(
             reg_info.ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP));
         const RegisterInfo *pc = reg_info.GetRegisterInfoAtIndex(
             reg_info.ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC));
         size_t byte_size = std::max(sp->byte_offset + sp->byte_size, pc->byte_offset + pc->byte_size);
 
         DataBufferSP reg_data_sp(new DataBufferHeap(byte_size, 0));
         m_reg_data.SetData(reg_data_sp);
     }
 
-    virtual ~RegisterContextGo() {}
+    ~RegisterContextGo() override = default;
 
-    virtual bool
-    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &reg_value)
+    bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info,
+                 lldb_private::RegisterValue &reg_value) override
     {
         switch (reg_info->kinds[eRegisterKindGeneric])
         {
             case LLDB_REGNUM_GENERIC_SP:
             case LLDB_REGNUM_GENERIC_PC:
                 return RegisterContextMemory::ReadRegister(reg_info, reg_value);
             default:
                 reg_value.SetValueToInvalid();
                 return true;
         }
     }
 
-    virtual bool
-    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &reg_value)
+    bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info,
+                  const lldb_private::RegisterValue &reg_value) override
     {
         switch (reg_info->kinds[eRegisterKindGeneric])
         {
             case LLDB_REGNUM_GENERIC_SP:
             case LLDB_REGNUM_GENERIC_PC:
                 return RegisterContextMemory::WriteRegister(reg_info, reg_value);
             default:
                 return false;
         }
     }
 
-  private:
     DISALLOW_COPY_AND_ASSIGN(RegisterContextGo);
 };
 
-}  // namespace
+} // anonymous namespace
 
 struct OperatingSystemGo::Goroutine
 {
     uint64_t m_lostack;
     uint64_t m_histack;
     uint64_t m_goid;
     addr_t m_gobuf;
     uint32_t m_status;
if (!force)
             }
         }
         if (!found_go_runtime)
             return nullptr;
     }
     return new OperatingSystemGo(process);
 }
 
+OperatingSystemGo::OperatingSystemGo(lldb_private::Process *process)
+    : OperatingSystem(process)
+    , m_reginfo(new DynamicRegisterInfo)
+{
+}
+
 ConstString
 OperatingSystemGo::GetPluginNameStatic()
 {
     static ConstString g_name("goroutines");
     return g_name;
 }
 
 const char *
 OperatingSystemGo::GetPluginDescriptionStatic()
 {
     return "Operating system plug-in that reads runtime data-structures for goroutines.";
 }
 
-OperatingSystemGo::OperatingSystemGo(lldb_private::Process *process)
-    : OperatingSystem(process)
-    , m_reginfo(new DynamicRegisterInfo)
-{
-}
-
-OperatingSystemGo::~OperatingSystemGo()
-{
-}
-
 bool
 OperatingSystemGo::Init(ThreadList &threads)
 {
     if (threads.GetSize(false) < 1)
         return false;
     TargetSP target_sp = m_process->CalculateTarget();
     if (!target_sp)
         return false;

lldb/trunk/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h

-//===-- OperatingSystemPython.h ---------------------------*- C++ -*-===//
+//===-- OperatingSystemPython.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef LLDB_DISABLE_PYTHON
 
 #ifndef liblldb_OperatingSystemPython_h_
 #define liblldb_OperatingSystemPython_h_
 
+#ifndef LLDB_DISABLE_PYTHON
+
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
+// Project includes
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Target/OperatingSystem.h"
 
 class DynamicRegisterInfo;
 
 namespace lldb_private
 {
 class ScriptInterpreter;
 }
 
 class OperatingSystemPython : public lldb_private::OperatingSystem
 {
 public:
+    OperatingSystemPython(lldb_private::Process *process,
+                          const lldb_private::FileSpec &python_module_path);
+
+    ~OperatingSystemPython() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static lldb_private::OperatingSystem *
     CreateInstance (lldb_private::Process *process, bool force);
     
     static void
     Initialize();
     
     static void
     Terminate();
     
     static lldb_private::ConstString
     GetPluginNameStatic();
     
     static const char *
     GetPluginDescriptionStatic();
     
     //------------------------------------------------------------------
-    // Class Methods
-    //------------------------------------------------------------------
-    OperatingSystemPython (lldb_private::Process *process,
-                           const lldb_private::FileSpec &python_module_path);
-    
-    virtual
-    ~OperatingSystemPython ();
-    
-    //------------------------------------------------------------------
     // lldb_private::PluginInterface Methods
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
     
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
     
     //------------------------------------------------------------------
     // lldb_private::OperatingSystem Methods
     //------------------------------------------------------------------
-    virtual bool
-    UpdateThreadList (lldb_private::ThreadList &old_thread_list,
-                      lldb_private::ThreadList &real_thread_list,
-                      lldb_private::ThreadList &new_thread_list);
+    bool
+    UpdateThreadList(lldb_private::ThreadList &old_thread_list,
+                     lldb_private::ThreadList &new_thread_list) override;
     
-    virtual void
-    ThreadWasSelected (lldb_private::Thread *thread);
+    void
+    ThreadWasSelected(lldb_private::Thread *thread) override;
 
-    virtual lldb::RegisterContextSP
-    CreateRegisterContextForThread (lldb_private::Thread *thread,
-                                    lldb::addr_t reg_data_addr);
+    lldb::RegisterContextSP
+    CreateRegisterContextForThread(lldb_private::Thread *thread,
+                                   lldb::addr_t reg_data_addr) override;
 
-    virtual lldb::StopInfoSP
-    CreateThreadStopReason (lldb_private::Thread *thread);
+    lldb::StopInfoSP
+    CreateThreadStopReason(lldb_private::Thread *thread) override;
 
     //------------------------------------------------------------------
     // Method for lazy creation of threads on demand
     //------------------------------------------------------------------
-    virtual lldb::ThreadSP
-    CreateThread (lldb::tid_t tid, lldb::addr_t context);
+    lldb::ThreadSP
+    CreateThread(lldb::tid_t tid, lldb::addr_t context) override;
 
 protected:
-    
     bool IsValid() const
     {
         return m_python_object_sp && m_python_object_sp->IsValid();
     }
 
     lldb::ThreadSP CreateThreadFromThreadInfo(lldb_private::StructuredData::Dictionary &thread_dict,
                                               lldb_private::ThreadList &core_thread_list, lldb_private::ThreadList &old_thread_list,
                                               std::vector<bool> &core_used_map, bool *did_create_ptr);
 
     DynamicRegisterInfo *
     GetDynamicRegisterInfo ();
 
     lldb::ValueObjectSP m_thread_list_valobj_sp;
     std::unique_ptr<DynamicRegisterInfo> m_register_info_ap;
     lldb_private::ScriptInterpreter *m_interpreter;
     lldb_private::StructuredData::ObjectSP m_python_object_sp;
 };
 
-#endif // #ifndef liblldb_OperatingSystemPython_h_
-#endif // #ifndef LLDB_DISABLE_PYTHON
+#endif // LLDB_DISABLE_PYTHON
+
+#endif // liblldb_OperatingSystemPython_h_

lldb/trunk/source/Plugins/Process/Utility/RegisterContextThreadMemory.h

 //===-- RegisterContextThreadMemory.h ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_RegisterContextThreadMemory_h_
 #define lldb_RegisterContextThreadMemory_h_
 
+// C Includes
+// C++ Includes
 #include <vector>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Symbol/SymbolContext.h"
 
 namespace lldb_private {
     
 class RegisterContextThreadMemory : public lldb_private::RegisterContext
 {
 public:
     RegisterContextThreadMemory (Thread &thread,
                                  lldb::addr_t register_data_addr);
     
-    virtual ~RegisterContextThreadMemory();
-    //------------------------------------------------------------------
-    // Subclasses must override these functions
-    //------------------------------------------------------------------
-    virtual void
-    InvalidateAllRegisters ();
-    
-    virtual size_t
-    GetRegisterCount ();
-    
-    virtual const RegisterInfo *
-    GetRegisterInfoAtIndex (size_t reg);
-    
-    virtual size_t
-    GetRegisterSetCount ();
-    
-    virtual const RegisterSet *
-    GetRegisterSet (size_t reg_set);
+    ~RegisterContextThreadMemory() override;
+    void
+    InvalidateAllRegisters() override;
+    
+    size_t
+    GetRegisterCount() override;
+    
+    const RegisterInfo *
+    GetRegisterInfoAtIndex(size_t reg) override;
+    
+    size_t
+    GetRegisterSetCount() override;
     
-    virtual bool
-    ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value);
+    const RegisterSet *
+    GetRegisterSet(size_t reg_set) override;
     
-    virtual bool
-    WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value);
+    bool
+    ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
+    
+    bool
+    WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
     
     // These two functions are used to implement "push" and "pop" of register states.  They are used primarily
     // for expression evaluation, where we need to push a new state (storing the old one in data_sp) and then
     // restoring the original state by passing the data_sp we got from ReadAllRegisters to WriteAllRegisterValues.
     // ReadAllRegisters will do what is necessary to return a coherent set of register values for this thread, which
     // may mean e.g. interrupting a thread that is sitting in a kernel trap.  That is a somewhat disruptive operation,
     // so these API's should only be used when this behavior is needed.
     
-    virtual bool
-    ReadAllRegisterValues (lldb::DataBufferSP &data_sp);
+    bool
+    ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
     
-    virtual bool
-    WriteAllRegisterValues (const lldb::DataBufferSP &data_sp);
+    bool
+    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
     
     bool
     CopyFromRegisterContext (lldb::RegisterContextSP context);
     
-    virtual uint32_t
-    ConvertRegisterKindToRegisterNumber (lldb::RegisterKind kind, uint32_t num);
-    
-    //------------------------------------------------------------------
-    // Subclasses can override these functions if desired
-    //------------------------------------------------------------------
-    virtual uint32_t
-    NumSupportedHardwareBreakpoints ();
+    uint32_t
+    ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
     
-    virtual uint32_t
-    SetHardwareBreakpoint (lldb::addr_t addr, size_t size);
+    uint32_t
+    NumSupportedHardwareBreakpoints() override;
     
-    virtual bool
-    ClearHardwareBreakpoint (uint32_t hw_idx);
+    uint32_t
+    SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
     
-    virtual uint32_t
-    NumSupportedHardwareWatchpoints ();
+    bool
+    ClearHardwareBreakpoint(uint32_t hw_idx) override;
     
-    virtual uint32_t
-    SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write);
+    uint32_t
+    NumSupportedHardwareWatchpoints() override;
     
-    virtual bool
-    ClearHardwareWatchpoint (uint32_t hw_index);
+    uint32_t
+    SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
     
-    virtual bool
-    HardwareSingleStep (bool enable);
+    bool
+    ClearHardwareWatchpoint(uint32_t hw_index) override;
     
-    virtual Error
-    ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, RegisterValue &reg_value);
+    bool
+    HardwareSingleStep(bool enable) override;
     
-    virtual Error
-    WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, const RegisterValue &reg_value);
-    
+    Error
+    ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info,
+                                lldb::addr_t src_addr,
+                                uint32_t src_len,
+                                RegisterValue &reg_value) override;
+    
+    Error
+    WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info,
+                               lldb::addr_t dst_addr, uint32_t dst_len,
+                               const RegisterValue &reg_value) override;
 protected:
     void
     UpdateRegisterContext ();
     
     lldb::ThreadWP m_thread_wp;
     lldb::RegisterContextSP m_reg_ctx_sp;
     lldb::addr_t m_register_data_addr;
     uint32_t m_stop_id;
+
 private:
     DISALLOW_COPY_AND_ASSIGN (RegisterContextThreadMemory);
 };
+
 } // namespace lldb_private
 
-#endif  // lldb_RegisterContextThreadMemory_h_
+#endif // lldb_RegisterContextThreadMemory_h_

lldb/trunk/source/Plugins/Process/Utility/StopInfoMachException.h

StopInfoMachException (Thread &thread,
                            uint64_t exc_subcode) :
         StopInfo (thread, exc_type),
         m_exc_data_count (exc_data_count),
         m_exc_code (exc_code),
         m_exc_subcode (exc_subcode)
     {
     }
 
-    virtual ~StopInfoMachException()
-    {
-    }
+    ~StopInfoMachException() override = default;
 
-
-    virtual lldb::StopReason
-    GetStopReason () const
+    lldb::StopReason
+    GetStopReason() const override
     {
         return lldb::eStopReasonException;
     }
 
-    virtual const char *
-    GetDescription ();
+    const char *
+    GetDescription() override;
 
     // Since some mach exceptions will be reported as breakpoints, signals,
     // or trace, we use this static accessor which will translate the mach
     // exception into the correct StopInfo.
     static lldb::StopInfoSP
     CreateStopReasonWithMachException (Thread &thread, 
                                        uint32_t exc_type, 
                                        uint32_t exc_data_count,
                                        uint64_t exc_code, 
                                        uint64_t exc_sub_code,
                                        uint64_t exc_sub_sub_code,
                                        bool pc_already_adjusted = true,
                                        bool adjust_pc_if_needed = false);
 
 protected:
     uint32_t m_exc_data_count;
     uint64_t m_exc_code;
     uint64_t m_exc_subcode;
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_StopInfoMachException_h_
+#endif // liblldb_StopInfoMachException_h_

lldb/trunk/source/Plugins/Process/Utility/ThreadMemory.h

-//===-- ThreadMemory.h -----------------------------------------*- C++ -*-===//
+//===-- ThreadMemory.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ThreadMemory_h_
 #define liblldb_ThreadMemory_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Target/Thread.h"
 
 class ThreadMemory :
     public lldb_private::Thread
 {
 public:
-
     ThreadMemory (lldb_private::Process &process,
                   lldb::tid_t tid,
                   const lldb::ValueObjectSP &thread_info_valobj_sp);
 
     ThreadMemory (lldb_private::Process &process,
                   lldb::tid_t tid,
                   const char *name,
                   const char *queue,
                   lldb::addr_t register_data_addr);
 
-    virtual
-    ~ThreadMemory();
+    ~ThreadMemory() override;
 
-    //------------------------------------------------------------------
-    // lldb_private::Thread methods
-    //------------------------------------------------------------------
-    virtual lldb::RegisterContextSP
-    GetRegisterContext ();
+    lldb::RegisterContextSP
+    GetRegisterContext() override;
 
-    virtual lldb::RegisterContextSP
-    CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+    lldb::RegisterContextSP
+    CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
-    virtual bool
-    CalculateStopInfo ();
+    bool
+    CalculateStopInfo() override;
 
-    virtual const char *
-    GetInfo ()
+    const char *
+    GetInfo() override
     {
         if (m_backing_thread_sp)
             m_backing_thread_sp->GetInfo();
         return NULL;
     }
 
-    virtual const char *
-    GetName ()
+    const char *
+    GetName() override
     {
         if (!m_name.empty())
             return m_name.c_str();
         if (m_backing_thread_sp)
             m_backing_thread_sp->GetName();
         return NULL;
     }
     
-    virtual const char *
-    GetQueueName ()
+    const char *
+    GetQueueName() override
     {
         if (!m_queue.empty())
             return m_queue.c_str();
         if (m_backing_thread_sp)
             m_backing_thread_sp->GetQueueName();
         return NULL;
     }
 
-    virtual void
-    WillResume (lldb::StateType resume_state);
+    void
+    WillResume(lldb::StateType resume_state) override;
 
-    virtual void
-    DidResume ()
+    void
+    DidResume() override
     {
         if (m_backing_thread_sp)
             m_backing_thread_sp->DidResume();
     }
     
-    virtual lldb::user_id_t
-    GetProtocolID () const
+    lldb::user_id_t
+    GetProtocolID() const override
     {
         if (m_backing_thread_sp)
             return m_backing_thread_sp->GetProtocolID();
         return Thread::GetProtocolID();
     }
 
-    virtual void
-    RefreshStateAfterStop();
+    void
+    RefreshStateAfterStop() override;
     
     lldb::ValueObjectSP &
     GetValueObject ()
     {
         return m_thread_info_valobj_sp;
     }
     
-    virtual void
-    ClearStackFrames ();
+    void
+    ClearStackFrames() override;
 
-    virtual void
-    ClearBackingThread ()
+    void
+    ClearBackingThread() override
     {
         m_backing_thread_sp.reset();
     }
 
-    virtual bool
-    SetBackingThread (const lldb::ThreadSP &thread_sp)
+    bool
+    SetBackingThread(const lldb::ThreadSP &thread_sp) override
     {
         //printf ("Thread 0x%llx is being backed by thread 0x%llx\n", GetID(), thread_sp->GetID());
         m_backing_thread_sp = thread_sp;
         return (bool)thread_sp;
     }
     
-    virtual lldb::ThreadSP
-    GetBackingThread () const
+    lldb::ThreadSP
+    GetBackingThread() const override
     {
         return m_backing_thread_sp;
     }
 
 protected:
-    
-    virtual bool
-    IsOperatingSystemPluginThread () const
+    bool
+    IsOperatingSystemPluginThread() const override
     {
         return true;
     }
     
-
-    //------------------------------------------------------------------
-    // For ThreadMemory and subclasses
-    //------------------------------------------------------------------
     // If this memory thread is actually represented by a thread from the
     // lldb_private::Process subclass, then fill in the thread here and
     // all APIs will be routed through this thread object. If m_backing_thread_sp
     // is empty, then this thread is simply in memory with no representation
     // through the process plug-in.
     lldb::ThreadSP m_backing_thread_sp;
     lldb::ValueObjectSP m_thread_info_valobj_sp;
     std::string m_name;
     std::string m_queue;
     lldb::addr_t m_register_data_addr;
+
 private:
-    //------------------------------------------------------------------
-    // For ThreadMemory only
-    //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ThreadMemory);
 };
 
-#endif  // liblldb_ThreadMemory_h_
+#endif // liblldb_ThreadMemory_h_

lldb/trunk/source/Plugins/Process/Utility/UnwindLLDB.h

 //===-- UnwindLLDB.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_UnwindLLDB_h_
 #define lldb_UnwindLLDB_h_
 
+// C Includes
+// C++ Includes
 #include <vector>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Unwind.h"
 
 namespace lldb_private {
 
 class RegisterContextLLDB;
 
 class UnwindLLDB : public lldb_private::Unwind
 {
 public: 
     UnwindLLDB (lldb_private::Thread &thread);
-    
-    virtual
-    ~UnwindLLDB() { }
+    ~UnwindLLDB() override = default;
 
     enum RegisterSearchResult
     {
         eRegisterFound = 0,
         eRegisterNotFound,
         eRegisterIsVolatile
     };
 
struct RegisterLocation {
             lldb::addr_t target_memory_location;
             uint32_t     register_number;       // in eRegisterKindLLDB register numbering system
             void*        host_memory_location;
             uint64_t     inferred_value;        // eRegisterValueInferred - e.g. stack pointer == cfa + offset
         } location;
     };
 
     void
-    DoClear()
+    DoClear() override
     {
         m_frames.clear();
         m_candidate_frame.reset();
         m_unwind_complete = false;
     }
 
-    virtual uint32_t
-    DoGetFrameCount();
+    uint32_t
+    DoGetFrameCount() override;
 
     bool
-    DoGetFrameInfoAtIndex (uint32_t frame_idx,
-                         lldb::addr_t& cfa, 
-                         lldb::addr_t& start_pc);
+    DoGetFrameInfoAtIndex(uint32_t frame_idx,
+                          lldb::addr_t& cfa,
+                          lldb::addr_t& start_pc) override;
     
     lldb::RegisterContextSP
-    DoCreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+    DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
     typedef std::shared_ptr<RegisterContextLLDB> RegisterContextLLDBSP;
 
     // Needed to retrieve the "next" frame (e.g. frame 2 needs to retrieve frame 1's RegisterContextLLDB)
     // The RegisterContext for frame_num must already exist or this returns an empty shared pointer.
     RegisterContextLLDBSP
     GetRegisterContextForFrameNum (uint32_t frame_num);
 
protected:
     //------------------------------------------------------------------
     const std::vector<ConstString> &
     GetUserSpecifiedTrapHandlerFunctionNames ()
     {
         return m_user_supplied_trap_handler_functions;
     }
 
 private:
-
     struct Cursor
     {
         lldb::addr_t start_pc;  // The start address of the function/symbol for this frame - current pc if unknown
         lldb::addr_t cfa;       // The canonical frame address for this stack frame
         lldb_private::SymbolContext sctx;  // A symbol context we'll contribute to & provide to the StackFrame creation
         RegisterContextLLDBSP reg_ctx_lldb_sp; // These are all RegisterContextLLDB's
 
         Cursor () : start_pc (LLDB_INVALID_ADDRESS), cfa (LLDB_INVALID_ADDRESS), sctx(), reg_ctx_lldb_sp() { }
private:
     AddFirstFrame ();
 
     //------------------------------------------------------------------
     // For UnwindLLDB only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (UnwindLLDB);
 };
 
-}   // namespace lldb_private
+} // namespace lldb_private
 
-#endif  // lldb_UnwindLLDB_h_
+#endif // lldb_UnwindLLDB_h_

lldb/trunk/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h

 #ifndef lldb_UnwindMacOSXFrameBackchain_h_
 #define lldb_UnwindMacOSXFrameBackchain_h_
 
 // C Includes
 // C++ Includes
 #include <vector>
 
 // Other libraries and framework includes
-
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/Unwind.h"
 
 class UnwindMacOSXFrameBackchain : public lldb_private::Unwind
 {
 public: 
     UnwindMacOSXFrameBackchain (lldb_private::Thread &thread);
-    
-    virtual
-    ~UnwindMacOSXFrameBackchain()
-    {
-    }
-    
+    ~UnwindMacOSXFrameBackchain() override = default;
 protected:
-    virtual void
-    DoClear()
+    void
+    DoClear() override
     {
         m_cursors.clear();
     }
 
-    virtual uint32_t
-    DoGetFrameCount();
+    uint32_t
+    DoGetFrameCount() override;
 
     bool
-    DoGetFrameInfoAtIndex (uint32_t frame_idx,
-                         lldb::addr_t& cfa, 
-                         lldb::addr_t& pc);
+    DoGetFrameInfoAtIndex(uint32_t frame_idx,
+                          lldb::addr_t& cfa,
+                          lldb::addr_t& pc) override;
     
     lldb::RegisterContextSP
-    DoCreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+    DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
     friend class RegisterContextMacOSXFrameBackchain;
 
     struct Cursor
     {
         lldb::addr_t pc;    // Program counter
         lldb::addr_t fp;    // Frame pointer for us with backchain
     };
 
 private:
     std::vector<Cursor> m_cursors;
 
     size_t
     GetStackFrameData_i386 (const lldb_private::ExecutionContext &exe_ctx);
 
     size_t
     GetStackFrameData_x86_64 (const lldb_private::ExecutionContext &exe_ctx);
 
     //------------------------------------------------------------------
     // For UnwindMacOSXFrameBackchain only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (UnwindMacOSXFrameBackchain);
 };
 
-#endif  // lldb_UnwindMacOSXFrameBackchain_h_
+#endif // lldb_UnwindMacOSXFrameBackchain_h_

lldb/trunk/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

 //===-- SystemRuntimeMacOSX.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SystemRuntimeMacOSX_h_
 #define liblldb_SystemRuntimeMacOSX_h_
 
 // C Includes
 // C++ Includes
-#include <map>
 #include <vector>
 #include <string>
 
-// Other libraries and framework includes
-
+// Other libraries and framework include
+// Project includes
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 
 #include "AppleGetItemInfoHandler.h"
 #include "AppleGetQueuesHandler.h"
 #include "AppleGetPendingItemsHandler.h"
 #include "AppleGetThreadItemInfoHandler.h"
 
 class SystemRuntimeMacOSX : public lldb_private::SystemRuntime
 {
 public:
+    SystemRuntimeMacOSX(lldb_private::Process *process);
+
+    ~SystemRuntimeMacOSX() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     static lldb_private::SystemRuntime *
     CreateInstance (lldb_private::Process *process);
 
-
     //------------------------------------------------------------------
     // instance methods
     //------------------------------------------------------------------
 
-    SystemRuntimeMacOSX (lldb_private::Process *process);
-
-    virtual
-    ~SystemRuntimeMacOSX ();
-
     void
-    Clear (bool clear_process);
+    Clear(bool clear_process);
 
     void
-    Detach ();
+    Detach() override;
 
     const std::vector<lldb_private::ConstString> &
-    GetExtendedBacktraceTypes ();
+    GetExtendedBacktraceTypes() override;
 
     lldb::ThreadSP
-    GetExtendedBacktraceThread (lldb::ThreadSP thread, lldb_private::ConstString type);
+    GetExtendedBacktraceThread(lldb::ThreadSP thread, lldb_private::ConstString type) override;
 
     lldb::ThreadSP
-    GetExtendedBacktraceForQueueItem (lldb::QueueItemSP queue_item_sp, lldb_private::ConstString type);
+    GetExtendedBacktraceForQueueItem(lldb::QueueItemSP queue_item_sp,
+                                     lldb_private::ConstString type) override;
 
     lldb::ThreadSP
     GetExtendedBacktraceFromItemRef (lldb::addr_t item_ref);
 
     void
-    PopulateQueueList (lldb_private::QueueList &queue_list);
+    PopulateQueueList(lldb_private::QueueList &queue_list) override;
 
     void
     PopulateQueuesUsingLibBTR (lldb::addr_t queues_buffer, uint64_t queues_buffer_size, uint64_t count, lldb_private::QueueList &queue_list);
 
     void
     PopulatePendingQueuesUsingLibBTR (lldb::addr_t items_buffer, uint64_t items_buffer_size, uint64_t count, lldb_private::Queue *queue);
 
     std::string
-    GetQueueNameFromThreadQAddress (lldb::addr_t dispatch_qaddr);
+    GetQueueNameFromThreadQAddress(lldb::addr_t dispatch_qaddr) override;
 
     lldb::queue_id_t
-    GetQueueIDFromThreadQAddress (lldb::addr_t dispatch_qaddr);
+    GetQueueIDFromThreadQAddress(lldb::addr_t dispatch_qaddr) override;
 
     lldb::addr_t
-    GetLibdispatchQueueAddressFromThreadQAddress (lldb::addr_t dispatch_qaddr);
+    GetLibdispatchQueueAddressFromThreadQAddress(lldb::addr_t dispatch_qaddr) override;
 
     void
-    PopulatePendingItemsForQueue (lldb_private::Queue *queue);
+    PopulatePendingItemsForQueue(lldb_private::Queue *queue) override;
 
     void
-    CompleteQueueItem (lldb_private::QueueItem *queue_item, lldb::addr_t item_ref);
+    CompleteQueueItem(lldb_private::QueueItem *queue_item, lldb::addr_t item_ref) override;
 
     virtual lldb::QueueKind
     GetQueueKind (lldb::addr_t dispatch_queue_addr);
 
-    virtual void
-    AddThreadExtendedInfoPacketHints (lldb_private::StructuredData::ObjectSP dict);
+    void
+    AddThreadExtendedInfoPacketHints(lldb_private::StructuredData::ObjectSP dict) override;
 
-    virtual bool
-    SafeToCallFunctionsOnThisThread (lldb::ThreadSP thread_sp);
+    bool
+    SafeToCallFunctionsOnThisThread(lldb::ThreadSP thread_sp) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
-
-    virtual uint32_t
-    GetPluginVersion();
+    lldb_private::ConstString
+    GetPluginName() override;
 
+    uint32_t
+    GetPluginVersion() override;
 
 protected:
     lldb::user_id_t m_break_id;
     mutable lldb_private::Mutex m_mutex;
 
 private:
-
     struct libBacktraceRecording_info {
         uint16_t    queue_info_version;
         uint16_t    queue_info_data_offset;
         uint16_t    item_info_version;
         uint16_t    item_info_data_offset;
 
         libBacktraceRecording_info () :
             queue_info_version(0),
             queue_info_data_offset(0),
             item_info_version(0),
             item_info_data_offset(0) {}
     };
 
-
     // A structure which reflects the data recorded in the
     // libBacktraceRecording introspection_dispatch_item_info_s.
     struct ItemInfo {
         lldb::addr_t    item_that_enqueued_this;
         lldb::addr_t    function_or_block;
         uint64_t        enqueuing_thread_id;
         uint64_t        enqueuing_queue_serialnum;
         uint64_t        target_queue_serialnum;
private:
     struct LibdispatchTSDIndexes        m_libdispatch_tsd_indexes;
 
     lldb::addr_t                        m_dispatch_voucher_offsets_addr;
     struct LibdispatchVoucherOffsets    m_libdispatch_voucher_offsets;
 
     DISALLOW_COPY_AND_ASSIGN (SystemRuntimeMacOSX);
 };
 
-#endif  // liblldb_SystemRuntimeMacOSX_h_
+#endif // liblldb_SystemRuntimeMacOSX_h_

lldb/trunk/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

-//===-- UnwindAssemblyInstEmulation.h ----------------------------*- C++ -*-===//
+//===-- UnwindAssemblyInstEmulation.h ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_UnwindAssemblyInstEmulation_h_
 #define liblldb_UnwindAssemblyInstEmulation_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/UnwindAssembly.h"
 
 class UnwindAssemblyInstEmulation : public lldb_private::UnwindAssembly
 {
 public:
+    ~UnwindAssemblyInstEmulation() override = default;
 
-    virtual
-    ~UnwindAssemblyInstEmulation () 
-    {
-    }
-
-    virtual bool
-    GetNonCallSiteUnwindPlanFromAssembly (lldb_private::AddressRange& func, 
-                                          lldb_private::Thread& thread, 
-                                          lldb_private::UnwindPlan& unwind_plan);
+    bool
+    GetNonCallSiteUnwindPlanFromAssembly(lldb_private::AddressRange& func,
+                                         lldb_private::Thread& thread,
+                                         lldb_private::UnwindPlan& unwind_plan) override;
 
-    virtual bool
-    AugmentUnwindPlanFromCallSite (lldb_private::AddressRange& func,
-                                   lldb_private::Thread& thread,
-                                   lldb_private::UnwindPlan& unwind_plan);
+    bool
+    AugmentUnwindPlanFromCallSite(lldb_private::AddressRange& func,
+                                  lldb_private::UnwindPlan& unwind_plan) override;
 
-    virtual bool
-    GetFastUnwindPlan (lldb_private::AddressRange& func, 
-                       lldb_private::Thread& thread, 
-                       lldb_private::UnwindPlan &unwind_plan);
+    bool
+    GetFastUnwindPlan(lldb_private::AddressRange& func,
+                      lldb_private::Thread& thread,
+                      lldb_private::UnwindPlan &unwind_plan) override;
 
     // thread may be NULL in which case we only use the Target (e.g. if this is called pre-process-launch).
-    virtual bool
-    FirstNonPrologueInsn (lldb_private::AddressRange& func, 
-                          const lldb_private::ExecutionContext &exe_ctx, 
-                          lldb_private::Address& first_non_prologue_insn);
+    bool
+    FirstNonPrologueInsn(lldb_private::AddressRange& func,
+                         const lldb_private::ExecutionContext &exe_ctx,
+                         lldb_private::Address& first_non_prologue_insn) override;
 
     static lldb_private::UnwindAssembly *
     CreateInstance (const lldb_private::ArchSpec &arch);
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
     
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
     
 private:
-    
+    // Call CreateInstance to get an instance of this class
+    UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch,
+                                lldb_private::EmulateInstruction *inst_emulator) :
+        UnwindAssembly (arch),
+        m_inst_emulator_ap (inst_emulator),
+        m_range_ptr (NULL),
+        m_thread_ptr (NULL),
+        m_unwind_plan_ptr (NULL),
+        m_curr_row (),
+        m_cfa_reg_info (),
+        m_fp_is_cfa (false),
+        m_register_values (),
+        m_pushed_regs(),
+        m_curr_row_modified (false),
+        m_forward_branch_offset (0)
+    {
+        if (m_inst_emulator_ap.get())
+        {
+            m_inst_emulator_ap->SetBaton (this);
+            m_inst_emulator_ap->SetCallbacks (ReadMemory, WriteMemory, ReadRegister, WriteRegister);
+        }
+    }
     static size_t
     ReadMemory (lldb_private::EmulateInstruction *instruction,
                 void *baton,
                 const lldb_private::EmulateInstruction::Context &context, 
                 lldb::addr_t addr, 
                 void *dst,
                 size_t length);
 
private:
     
     static bool
     WriteRegister (lldb_private::EmulateInstruction *instruction,
                    void *baton,
                    const lldb_private::EmulateInstruction::Context &context, 
                    const lldb_private::RegisterInfo *reg_info,
                    const lldb_private::RegisterValue &reg_value);
 
-
 //    size_t
 //    ReadMemory (lldb_private::EmulateInstruction *instruction,
 //                const lldb_private::EmulateInstruction::Context &context, 
 //                lldb::addr_t addr, 
 //                void *dst,
 //                size_t length);
     
     size_t
ReadRegister (lldb_private::EmulateInstruction *instruction,
                   lldb_private::RegisterValue &reg_value);
 
     bool
     WriteRegister (lldb_private::EmulateInstruction *instruction,
                    const lldb_private::EmulateInstruction::Context &context, 
                    const lldb_private::RegisterInfo *reg_info,
                    const lldb_private::RegisterValue &reg_value);
 
-    // Call CreateInstance to get an instance of this class
-    UnwindAssemblyInstEmulation (const lldb_private::ArchSpec &arch,
-                                 lldb_private::EmulateInstruction *inst_emulator) :
-        UnwindAssembly (arch),
-        m_inst_emulator_ap (inst_emulator),
-        m_range_ptr (NULL),
-        m_thread_ptr (NULL),
-        m_unwind_plan_ptr (NULL),
-        m_curr_row (),
-        m_cfa_reg_info (),
-        m_fp_is_cfa (false),
-        m_register_values (),
-        m_pushed_regs(),
-        m_curr_row_modified (false),
-        m_forward_branch_offset (0)
-    {
-        if (m_inst_emulator_ap.get())
-        {
-            m_inst_emulator_ap->SetBaton (this);
-            m_inst_emulator_ap->SetCallbacks (ReadMemory, WriteMemory, ReadRegister, WriteRegister);
-        }
-    }
-
     static uint64_t 
     MakeRegisterKindValuePair (const lldb_private::RegisterInfo &reg_info);
     
     void
     SetRegisterValue (const lldb_private::RegisterInfo &reg_info, 
                       const lldb_private::RegisterValue &reg_value);
 
     bool

lldb/trunk/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h

-//===-- UnwindAssembly-x86.h -------------------------------------*- C++ -*-===//
+//===-- UnwindAssembly-x86.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_UnwindAssembly_x86_h_
 #define liblldb_UnwindAssembly_x86_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
 #include "llvm-c/Disassembler.h"
 
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/UnwindAssembly.h"
 
 class UnwindAssembly_x86 : public lldb_private::UnwindAssembly
 {
 public:
+    ~UnwindAssembly_x86() override;
 
-    ~UnwindAssembly_x86 ();
-
-    virtual bool
-    GetNonCallSiteUnwindPlanFromAssembly (lldb_private::AddressRange& func, 
-                                          lldb_private::Thread& thread, 
-                                          lldb_private::UnwindPlan& unwind_plan);
+    bool
+    GetNonCallSiteUnwindPlanFromAssembly(lldb_private::AddressRange& func,
+                                         lldb_private::Thread& thread,
+                                         lldb_private::UnwindPlan& unwind_plan) override;
 
-    virtual bool
-    AugmentUnwindPlanFromCallSite (lldb_private::AddressRange& func,
-                                   lldb_private::Thread& thread,
-                                   lldb_private::UnwindPlan& unwind_plan);
+    bool
+    AugmentUnwindPlanFromCallSite(lldb_private::AddressRange& func,
+                                  lldb_private::UnwindPlan& unwind_plan) override;
 
-    virtual bool
-    GetFastUnwindPlan (lldb_private::AddressRange& func, 
-                       lldb_private::Thread& thread, 
-                       lldb_private::UnwindPlan &unwind_plan);
+    bool
+    GetFastUnwindPlan(lldb_private::AddressRange& func,
+                      lldb_private::Thread& thread,
+                      lldb_private::UnwindPlan &unwind_plan) override;
 
     // thread may be NULL in which case we only use the Target (e.g. if this is called pre-process-launch).
-    virtual bool
-    FirstNonPrologueInsn (lldb_private::AddressRange& func, 
-                          const lldb_private::ExecutionContext &exe_ctx,
-                          lldb_private::Address& first_non_prologue_insn);
+    bool
+    FirstNonPrologueInsn(lldb_private::AddressRange& func,
+                         lldb_private::Address& first_non_prologue_insn) override;
 
     static lldb_private::UnwindAssembly *
     CreateInstance (const lldb_private::ArchSpec &arch);
 
-
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
     
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
     
 private:
     UnwindAssembly_x86 (const lldb_private::ArchSpec &arch, int cpu);
 
     int m_cpu;
     lldb_private::ArchSpec m_arch;
 };
 
-
 #endif // liblldb_UnwindAssembly_x86_h_