[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/Process/elf-core/ProcessElfCore.h

-//===-- ProcessElfCore.h ---------------------------------------*- C++ -*-===//
+//===-- ProcessElfCore.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 // Notes about Linux Process core dumps:
 //  1) Linux core dump is stored as ELF file.
 //  2) The ELF file's PT_NOTE and PT_LOAD segments describes the program's
 //     address space and thread contexts.
 //  3) PT_NOTE segment contains note entries which describes a thread context.
 //  4) PT_LOAD segment describes a valid contiguous range of process address
 //     space.
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ProcessElfCore_h_
 #define liblldb_ProcessElfCore_h_
 
+// C Includes
 // C++ Includes
 #include <list>
 #include <vector>
 
 // Other libraries and framework includes
+// Project includes
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Target/Process.h"
 
 #include "Plugins/ObjectFile/ELF/ELFHeader.h"
 
 struct ThreadData;
 
public:
 
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     ProcessElfCore(lldb::TargetSP target_sp,
                    lldb_private::Listener &listener,
                    const lldb_private::FileSpec &core_file);
 
-    virtual
-    ~ProcessElfCore();
+    ~ProcessElfCore() override;
 
     //------------------------------------------------------------------
     // Check if a given Process
     //------------------------------------------------------------------
     bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override;
 
     //------------------------------------------------------------------
     // Creating a new process, or attaching to an existing one
private:
     uint32_t
     GetNumThreadContexts();
 
     // Parse a contiguous address range of the process from LOAD segment
     lldb::addr_t
     AddAddressRangeFromLoadSegment(const elf::ELFProgramHeader *header);
 };
 
-#endif  // liblldb_ProcessElffCore_h_
+#endif // liblldb_ProcessElfCore_h_

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm.h

-//===-- RegisterContextCorePOSIX_arm.h -----------------------*- C++ -*-===//
+//===-- RegisterContextCorePOSIX_arm.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_RegisterContextCorePOSIX_arm_H_
-#define liblldb_RegisterContextCorePOSIX_arm_H_
+#ifndef liblldb_RegisterContextCorePOSIX_arm_h_
+#define liblldb_RegisterContextCorePOSIX_arm_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm.h"
 
 class RegisterContextCorePOSIX_arm :
     public RegisterContextPOSIX_arm
 {
 public:
     RegisterContextCorePOSIX_arm (lldb_private::Thread &thread,
                                      lldb_private::RegisterInfoInterface *register_info,
                                      const lldb_private::DataExtractor &gpregset,
                                      const lldb_private::DataExtractor &fpregset);
 
-    ~RegisterContextCorePOSIX_arm();
+    ~RegisterContextCorePOSIX_arm() override;
 
-    virtual bool
-    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value);
+    bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info,
+                 lldb_private::RegisterValue &value) override;
 
-    virtual bool
-    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value);
+    bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info,
+                  const lldb_private::RegisterValue &value) override;
 
     bool
-    ReadAllRegisterValues(lldb::DataBufferSP &data_sp);
+    ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
     bool
-    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp);
+    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
     bool
-    HardwareSingleStep(bool enable);
+    HardwareSingleStep(bool enable) override;
 
 protected:
     bool
-    ReadGPR();
+    ReadGPR() override;
 
     bool
-    ReadFPR();
+    ReadFPR() override;
 
     bool
-    WriteGPR();
+    WriteGPR() override;
 
     bool
-    WriteFPR();
+    WriteFPR() override;
 
 private:
     lldb::DataBufferSP m_gpr_buffer;
     lldb_private::DataExtractor m_gpr;
 };
 
-#endif // #ifndef liblldb_RegisterContextCorePOSIX_arm_H_
+#endif // liblldb_RegisterContextCorePOSIX_arm_h_

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

-//===-- RegisterContextCorePOSIX_arm64.h -----------------------*- C++ -*-===//
+//===-- RegisterContextCorePOSIX_arm64.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_RegisterContextCorePOSIX_arm64_H_
-#define liblldb_RegisterContextCorePOSIX_arm64_H_
+#ifndef liblldb_RegisterContextCorePOSIX_arm64_h_
+#define liblldb_RegisterContextCorePOSIX_arm64_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
 
 class RegisterContextCorePOSIX_arm64 :
     public RegisterContextPOSIX_arm64
 {
 public:
     RegisterContextCorePOSIX_arm64 (lldb_private::Thread &thread,
                                      lldb_private::RegisterInfoInterface *register_info,
                                      const lldb_private::DataExtractor &gpregset,
                                      const lldb_private::DataExtractor &fpregset);
 
-    ~RegisterContextCorePOSIX_arm64();
+    ~RegisterContextCorePOSIX_arm64() override;
 
-    virtual bool
-    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value);
+    bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info,
+                 lldb_private::RegisterValue &value) override;
 
-    virtual bool
-    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value);
+    bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info,
+                  const lldb_private::RegisterValue &value) override;
 
     bool
-    ReadAllRegisterValues(lldb::DataBufferSP &data_sp);
+    ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
     bool
-    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp);
+    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
     bool
-    HardwareSingleStep(bool enable);
+    HardwareSingleStep(bool enable) override;
 
 protected:
     bool
-    ReadGPR();
+    ReadGPR() override;
 
     bool
-    ReadFPR();
+    ReadFPR() override;
 
     bool
-    WriteGPR();
+    WriteGPR() override;
 
     bool
-    WriteFPR();
+    WriteFPR() override;
 
 private:
     lldb::DataBufferSP m_gpr_buffer;
     lldb_private::DataExtractor m_gpr;
 };
 
-#endif // #ifndef liblldb_RegisterContextCorePOSIX_arm64_H_
+#endif // liblldb_RegisterContextCorePOSIX_arm64_h_

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.h

-//===-- RegisterContextCorePOSIX_mips64.h ----------------------*- C++ -*-===//
+//===-- RegisterContextCorePOSIX_mips64.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_RegisterContextCorePOSIX_mips64_H_
-#define liblldb_RegisterContextCorePOSIX_mips64_H_
+#ifndef liblldb_RegisterContextCorePOSIX_mips64_h_
+#define liblldb_RegisterContextCorePOSIX_mips64_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "Plugins/Process/Utility/RegisterContextPOSIX_mips64.h"
 
 class RegisterContextCorePOSIX_mips64 :
     public RegisterContextPOSIX_mips64
 {
 public:
     RegisterContextCorePOSIX_mips64 (lldb_private::Thread &thread,
                                      lldb_private::RegisterInfoInterface *register_info,
                                      const lldb_private::DataExtractor &gpregset,
                                      const lldb_private::DataExtractor &fpregset);
 
-    ~RegisterContextCorePOSIX_mips64();
+    ~RegisterContextCorePOSIX_mips64() override;
 
-    virtual bool
-    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value);
+    bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info,
+                 lldb_private::RegisterValue &value) override;
 
-    virtual bool
-    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value);
+    bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info,
+                  const lldb_private::RegisterValue &value) override;
 
     bool
-    ReadAllRegisterValues(lldb::DataBufferSP &data_sp);
+    ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
     bool
-    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp);
+    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
     bool
-    HardwareSingleStep(bool enable);
+    HardwareSingleStep(bool enable) override;
 
 protected:
     bool
-    ReadGPR();
+    ReadGPR() override;
 
     bool
-    ReadFPR();
+    ReadFPR() override;
 
     bool
-    WriteGPR();
+    WriteGPR() override;
 
     bool
-    WriteFPR();
+    WriteFPR() override;
 
 private:
     lldb::DataBufferSP m_gpr_buffer;
     lldb_private::DataExtractor m_gpr;
 };
 
-#endif // #ifndef liblldb_RegisterContextCorePOSIX_mips64_H_
+#endif // liblldb_RegisterContextCorePOSIX_mips64_h_

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_powerpc.h

 //===-- RegisterContextCorePOSIX_powerpc.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_RegisterContextCorePOSIX_powerpc_H_
-#define liblldb_RegisterContextCorePOSIX_powerpc_H_
+#ifndef liblldb_RegisterContextCorePOSIX_powerpc_h_
+#define liblldb_RegisterContextCorePOSIX_powerpc_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
 
 class RegisterContextCorePOSIX_powerpc :
     public RegisterContextPOSIX_powerpc
 {
 public:
     RegisterContextCorePOSIX_powerpc (lldb_private::Thread &thread,
                                      lldb_private::RegisterInfoInterface *register_info,
                                      const lldb_private::DataExtractor &gpregset,
                                      const lldb_private::DataExtractor &fpregset,
                                      const lldb_private::DataExtractor &vregset);
 
-    ~RegisterContextCorePOSIX_powerpc();
+    ~RegisterContextCorePOSIX_powerpc() override;
 
-    virtual bool
-    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value);
+    bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info,
+                 lldb_private::RegisterValue &value) override;
 
-    virtual bool
-    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value);
+    bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info,
+                  const lldb_private::RegisterValue &value) override;
 
     bool
-    ReadAllRegisterValues(lldb::DataBufferSP &data_sp);
+    ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
     bool
-    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp);
+    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
     bool
-    HardwareSingleStep(bool enable);
+    HardwareSingleStep(bool enable) override;
 
 protected:
     bool
-    ReadGPR();
+    ReadGPR() override;
 
     bool
-    ReadFPR();
+    ReadFPR() override;
 
     bool
-    ReadVMX();
+    ReadVMX() override;
 
     bool
-    WriteGPR();
+    WriteGPR() override;
 
     bool
-    WriteFPR();
+    WriteFPR() override;
 
     bool
-    WriteVMX();
+    WriteVMX() override;
 
 private:
     lldb::DataBufferSP m_gpr_buffer;
     lldb::DataBufferSP m_fpr_buffer;
     lldb::DataBufferSP m_vec_buffer;
     lldb_private::DataExtractor m_gpr;
     lldb_private::DataExtractor m_fpr;
     lldb_private::DataExtractor m_vec;
 };
 
-#endif // #ifndef liblldb_RegisterContextCorePOSIX_powerpc_H_
+#endif // liblldb_RegisterContextCorePOSIX_powerpc_h_

lldb/trunk/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h

-//===-- RegisterContextCorePOSIX_x86_64.h ----------------------*- C++ -*-===//
+//===-- RegisterContextCorePOSIX_x86_64.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_RegisterContextCorePOSIX_x86_64_H_
-#define liblldb_RegisterContextCorePOSIX_x86_64_H_
+#ifndef liblldb_RegisterContextCorePOSIX_x86_64_h_
+#define liblldb_RegisterContextCorePOSIX_x86_64_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "Plugins/Process/Utility/RegisterContextPOSIX_x86.h"
 
 class RegisterContextCorePOSIX_x86_64 :
     public RegisterContextPOSIX_x86
 {
 public:
     RegisterContextCorePOSIX_x86_64 (lldb_private::Thread &thread,
                                      lldb_private::RegisterInfoInterface *register_info,
                                      const lldb_private::DataExtractor &gpregset,
                                      const lldb_private::DataExtractor &fpregset);
 
-    ~RegisterContextCorePOSIX_x86_64();
+    ~RegisterContextCorePOSIX_x86_64() override;
 
-    virtual bool
-    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value);
+    bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info,
+                 lldb_private::RegisterValue &value) override;
 
-    virtual bool
-    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value);
+    bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info,
+                  const lldb_private::RegisterValue &value) override;
 
     bool
-    ReadAllRegisterValues(lldb::DataBufferSP &data_sp);
+    ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
     bool
-    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp);
+    WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
     bool
-    HardwareSingleStep(bool enable);
+    HardwareSingleStep(bool enable) override;
 
 protected:
     bool
-    ReadGPR();
+    ReadGPR() override;
 
     bool
-    ReadFPR();
+    ReadFPR() override;
 
     bool
-    WriteGPR();
+    WriteGPR() override;
 
     bool
-    WriteFPR();
+    WriteFPR() override;
 
 private:
     uint8_t *m_gpregset;
 };
 
-#endif // #ifndef liblldb_RegisterContextCorePOSIX_x86_64_H_
+#endif // liblldb_RegisterContextCorePOSIX_x86_64_h_

lldb/trunk/source/Plugins/Process/elf-core/ThreadElfCore.h

-//===-- ThreadElfCore.h ----------------------------------------*- C++ -*-===//
+//===-- ThreadElfCore.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_ThreadElfCore_h_
 #define liblldb_ThreadElfCore_h_
 
+// C Includes
+// C++ Includes
 #include <string>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Target/Thread.h"
 #include "lldb/Core/DataExtractor.h"
 
 struct compat_timeval
 {
     int64_t tv_sec;
     int32_t tv_usec;
 };
GetSize(lldb_private::ArchSpec &arch)
         switch(arch.GetCore())
         {
             case lldb_private::ArchSpec::eCore_x86_64_x86_64:
                 return ELFLINUXPRPSINFO64_SIZE;
             default:
                 return 0;
         }
     }
-
 };
 
 struct ThreadData
 {
     lldb_private::DataExtractor gpregset;
     lldb_private::DataExtractor fpregset;
     lldb_private::DataExtractor vregset;
     lldb::tid_t tid;
     int signo;
     std::string name;
 };
 
 class ThreadElfCore : public lldb_private::Thread
 {
 public:
     ThreadElfCore (lldb_private::Process &process, const ThreadData &td);
 
-    virtual
-    ~ThreadElfCore ();
+    ~ThreadElfCore() override;
 
-    virtual void
-    RefreshStateAfterStop();
+    void
+    RefreshStateAfterStop() override;
 
-    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 void
-    ClearStackFrames ();
+    void
+    ClearStackFrames() override;
 
     static bool
     ThreadIDIsValid (lldb::tid_t thread)
     {
         return thread != 0;
     }
 
-    virtual const char *
-    GetName ()
+    const char *
+    GetName() override
     {
         if (m_thread_name.empty())
             return NULL;
         return m_thread_name.c_str();
     }
 
     void
-    SetName (const char *name)
+    SetName(const char *name) override
     {
         if (name && name[0])
             m_thread_name.assign (name);
         else
             m_thread_name.clear();
     }
 
 protected:
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     std::string m_thread_name;
     lldb::RegisterContextSP m_thread_reg_ctx_sp;
 
     int m_signo;
 
     lldb_private::DataExtractor m_gpregset_data;
     lldb_private::DataExtractor m_fpregset_data;
     lldb_private::DataExtractor m_vregset_data;
 
-    virtual bool CalculateStopInfo();
-
+    bool CalculateStopInfo() override;
 };
 
-#endif  // liblldb_ThreadElfCore_h_
+#endif // liblldb_ThreadElfCore_h_

lldb/trunk/source/Plugins/Process/mach-core/ProcessMachCore.h

 //===-- ProcessMachCore.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_ProcessMachCore_h_
 #define liblldb_ProcessMachCore_h_
 
 // C Includes
-
 // C++ Includes
 #include <list>
 #include <vector>
 
 // Other libraries and framework includes
+// Project includes
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Target/Process.h"
 
 class ThreadKDP;
 
 class ProcessMachCore : public lldb_private::Process
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
+    ProcessMachCore(lldb::TargetSP target_sp, 
+                    lldb_private::Listener &listener,
+                    const lldb_private::FileSpec &core_file);
+    
+    ~ProcessMachCore() override;
+    
     static lldb::ProcessSP
     CreateInstance (lldb::TargetSP target_sp, 
                     lldb_private::Listener &listener, 
                     const lldb_private::FileSpec *crash_file_path);
     
     static void
     Initialize();
     
     static void
     Terminate();
     
     static lldb_private::ConstString
     GetPluginNameStatic();
     
     static const char *
     GetPluginDescriptionStatic();
     
     //------------------------------------------------------------------
-    // Constructors and Destructors
-    //------------------------------------------------------------------
-    ProcessMachCore(lldb::TargetSP target_sp, 
-                    lldb_private::Listener &listener,
-                    const lldb_private::FileSpec &core_file);
-    
-    virtual
-    ~ProcessMachCore();
-    
-    //------------------------------------------------------------------
     // Check if a given Process
     //------------------------------------------------------------------
     bool
     CanDebug (lldb::TargetSP target_sp,
               bool plugin_specified_by_name) override;
     
     //------------------------------------------------------------------
     // Creating a new process, or attaching to an existing one
public:
     GetImageInfoAddress () override;
 
 protected:
     friend class ThreadMachCore;
     
     void
     Clear ( );
     
-    virtual bool
+    bool
     UpdateThreadList (lldb_private::ThreadList &old_thread_list, 
                       lldb_private::ThreadList &new_thread_list) override;
     
     lldb_private::ObjectFile *
     GetCoreObjectFile ();
 private:
     bool 
     GetDynamicLoaderAddress (lldb::addr_t addr);
private:
     typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, FileRange> VMRangeToFileOffset;
 
     VMRangeToFileOffset m_core_aranges;
     lldb::ModuleSP m_core_module_sp;
     lldb_private::FileSpec m_core_file;
     lldb::addr_t m_dyld_addr;
     lldb::addr_t m_mach_kernel_addr;
     lldb_private::ConstString m_dyld_plugin_name;
-    DISALLOW_COPY_AND_ASSIGN (ProcessMachCore);
-    
+    DISALLOW_COPY_AND_ASSIGN (ProcessMachCore);
 };
 
-#endif  // liblldb_ProcessMachCore_h_
+#endif // liblldb_ProcessMachCore_h_

lldb/trunk/source/Plugins/Process/mach-core/ThreadMachCore.h

 //===-- ThreadMachCore.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_ThreadMachCore_h_
 #define liblldb_ThreadMachCore_h_
 
+// C Includes
+// C++ Includes
 #include <string>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Target/Thread.h"
 
 class ProcessMachCore;
 
 class ThreadMachCore : public lldb_private::Thread
 {
 public:
     ThreadMachCore (lldb_private::Process &process,
                     lldb::tid_t tid);
 
-    virtual
-    ~ThreadMachCore ();
+    ~ThreadMachCore() override;
 
-    virtual void
-    RefreshStateAfterStop();
+    void
+    RefreshStateAfterStop() override;
 
-    virtual const char *
-    GetName ();
+    const char *
+    GetName() override;
 
-    virtual lldb::RegisterContextSP
-    GetRegisterContext ();
+    lldb::RegisterContextSP
+    GetRegisterContext() override;
 
-    virtual lldb::RegisterContextSP
-    CreateRegisterContextForFrame (lldb_private::StackFrame *frame);
+    lldb::RegisterContextSP
+    CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
 
     static bool
     ThreadIDIsValid (lldb::tid_t thread);
 
     bool
     ShouldStop (bool &step_more);
 
     const char *
     GetBasicInfoAsString ();
 
     void
-    SetName (const char *name)
+    SetName(const char *name) override
     {
         if (name && name[0])
             m_thread_name.assign (name);
         else
             m_thread_name.clear();
     }
 
     lldb::addr_t
     GetThreadDispatchQAddr ()
     {
         return m_thread_dispatch_qaddr;
     }
 
     void
     SetThreadDispatchQAddr (lldb::addr_t thread_dispatch_qaddr)
     {
         m_thread_dispatch_qaddr = thread_dispatch_qaddr;
     }
 
 protected:
-    
     friend class ProcessMachCore;
 
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     std::string m_thread_name;
     std::string m_dispatch_queue_name;
     lldb::addr_t m_thread_dispatch_qaddr;
     lldb::RegisterContextSP m_thread_reg_ctx_sp;
+
     //------------------------------------------------------------------
     // Protected member functions.
     //------------------------------------------------------------------
-    virtual bool
-    CalculateStopInfo ();
+    bool
+    CalculateStopInfo() override;
 };
 
-#endif  // liblldb_ThreadMachCore_h_
+#endif // liblldb_ThreadMachCore_h_

lldb/trunk/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h

 //===-- ScriptInterpreterNone.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_ScriptInterpreterNone_h_
 #define liblldb_ScriptInterpreterNone_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Interpreter/ScriptInterpreter.h"
 
 namespace lldb_private
 {
 
 class ScriptInterpreterNone : public ScriptInterpreter
 {
   public:
     ScriptInterpreterNone(CommandInterpreter &interpreter);
 
-    ~ScriptInterpreterNone();
+    ~ScriptInterpreterNone() override;
 
     bool
     ExecuteOneLine(const char *command, CommandReturnObject *result,
-                   const ExecuteScriptOptions &options = ExecuteScriptOptions());
+                   const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
     void
-    ExecuteInterpreterLoop();
+    ExecuteInterpreterLoop() override;
 
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb::ScriptInterpreterSP
     CreateInstance(CommandInterpreter &interpreter);
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 };
 
 } // namespace lldb_private
 
-#endif // #ifndef liblldb_ScriptInterpreterNone_h_
+#endif // liblldb_ScriptInterpreterNone_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 //===-- DWARFASTParserClang.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFASTParserClang_h_
 #define SymbolFileDWARF_DWARFASTParserClang_h_
 
-#include "DWARFDefines.h"
-#include "DWARFASTParser.h"
-
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "clang/AST/CharUnits.h"
 
+// Project includes
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "DWARFDefines.h"
+#include "DWARFASTParser.h"
 
 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
 
 class DWARFASTParserClang : public DWARFASTParser
 {
 public:
     DWARFASTParserClang (lldb_private::ClangASTContext &ast);
 
-    virtual ~DWARFASTParserClang ();
+    ~DWARFASTParserClang() override;
 
     lldb::TypeSP
     ParseTypeFromDWARF (const lldb_private::SymbolContext& sc,
                         const DWARFDIE &die,
                         lldb_private::Log *log,
                         bool *type_is_new_ptr) override;
 
 
-    virtual lldb_private::Function *
+    lldb_private::Function *
     ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
                             const DWARFDIE &die) override;
 
-    virtual bool
+    bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &compiler_type) override;
 
-    virtual lldb_private::CompilerDecl
+    lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) override;
 
-    virtual std::vector<DWARFDIE>
+    std::vector<DWARFDIE>
     GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override;
 
-    virtual lldb_private::CompilerDeclContext
+    lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) override;
 
-    virtual lldb_private::CompilerDeclContext
+    lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) override;
 
     bool
     LayoutRecordType(const clang::RecordDecl *record_decl,
                      uint64_t &bit_size,
                      uint64_t &alignment,
                      llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets);
-protected:
 
+protected:
     class DelayedAddObjCClassProperty;
     typedef std::vector <DelayedAddObjCClassProperty> DelayedPropertyList;
 
     struct LayoutInfo
     {
         LayoutInfo () :
         bit_size(0),
         alignment(0),
ParseChildParameters (const lldb_private::SymbolContext& sc,
                           const DWARFDIE &parent_die,
                           bool skip_artificial,
                           bool &is_static,
                           bool &is_variadic,
                           std::vector<lldb_private::CompilerType>& function_args,
                           std::vector<clang::ParmVarDecl*>& function_param_decls,
                           unsigned &type_quals);
 
-
     void
     ParseChildArrayInfo (const lldb_private::SymbolContext& sc,
                          const DWARFDIE &parent_die,
                          int64_t& first_index,
                          std::vector<uint64_t>& element_orders,
                          uint32_t& byte_stride,
                          uint32_t& bit_stride);
 
-
     size_t
     ParseChildEnumerators (const lldb_private::SymbolContext& sc,
                            lldb_private::CompilerType &compiler_type,
                            bool is_signed,
                            uint32_t enumerator_byte_size,
                            const DWARFDIE &parent_die);
 
     lldb_private::Type *
protected:
     lldb_private::ClangASTContext &m_ast;
     DIEToDeclMap m_die_to_decl;
     DeclToDIEMap m_decl_to_die;
     DIEToDeclContextMap m_die_to_decl_ctx;
     DeclContextToDIEMap m_decl_ctx_to_die;
     RecordDeclToLayoutMap m_record_decl_to_layout_map;
 };
 
-#endif  // SymbolFileDWARF_DWARFASTParserClang_h_
+#endif // SymbolFileDWARF_DWARFASTParserClang_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h

-//===-- DWARFASTParserGo.h -----------------------------------*- C++ -*-===//
+//===-- DWARFASTParserGo.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFASTParserGo_h_
 #define SymbolFileDWARF_DWARFASTParserGo_h_
 
-#include "DWARFDefines.h"
-#include "DWARFASTParser.h"
-#include "DWARFDIE.h"
-
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
+// Project includes
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/GoASTContext.h"
+#include "DWARFDefines.h"
+#include "DWARFASTParser.h"
+#include "DWARFDIE.h"
 
 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
 
 class DWARFASTParserGo : public DWARFASTParser
 {
-  public:
     DWARFASTParserGo(lldb_private::GoASTContext &ast);
 
-    virtual ~DWARFASTParserGo();
+    ~DWARFASTParserGo() override;
 
     lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, const DWARFDIE &die, lldb_private::Log *log,
                                     bool *type_is_new_ptr) override;
 
-    virtual lldb_private::Function *ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
-                                                           const DWARFDIE &die) override;
+    lldb_private::Function *
+    ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
 
-    virtual bool CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
-                                       lldb_private::CompilerType &go_type) override;
+    bool
+    CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
 
-    virtual lldb_private::CompilerDeclContext
+    lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override
     {
         return lldb_private::CompilerDeclContext();
     }
 
-    virtual lldb_private::CompilerDeclContext
+    lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override
     {
         return lldb_private::CompilerDeclContext();
     }
 
-    virtual lldb_private::CompilerDecl
+    lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) override
     {
         return lldb_private::CompilerDecl();
     }
 
-    virtual std::vector<DWARFDIE>
+    std::vector<DWARFDIE>
     GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override
     {
         return std::vector<DWARFDIE>();
     }
 
-  private:
     size_t ParseChildParameters(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, bool &is_variadic,
                                 std::vector<lldb_private::CompilerType> &function_param_types);
     void ParseChildArrayInfo(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, int64_t &first_index,
                              std::vector<uint64_t> &element_orders, uint32_t &byte_stride, uint32_t &bit_stride);
 
     size_t ParseChildMembers(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                              lldb_private::CompilerType &class_compiler_type);
 
     lldb_private::GoASTContext &m_ast;
 };
 
 #endif // SymbolFileDWARF_DWARFASTParserGo_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/LogChannelDWARF.h

-//===-- LogChannelDWARF.h --------------------------------------*- C++ -*-===//
+//===-- LogChannelDWARF.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_LogChannelDWARF_h_
 #define SymbolFileDWARF_LogChannelDWARF_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-
 // Project includes
 #include "lldb/Core/Log.h"
 
 #define DWARF_LOG_VERBOSE           (1u << 0)
 #define DWARF_LOG_DEBUG_INFO        (1u << 1)
 #define DWARF_LOG_DEBUG_LINE        (1u << 2)
 #define DWARF_LOG_DEBUG_PUBNAMES    (1u << 3)
 #define DWARF_LOG_DEBUG_PUBTYPES    (1u << 4)
 #define DWARF_LOG_DEBUG_ARANGES     (1u << 5)
 #define DWARF_LOG_LOOKUPS           (1u << 6)
 #define DWARF_LOG_TYPE_COMPLETION   (1u << 7)
 #define DWARF_LOG_DEBUG_MAP         (1u << 8)
 #define DWARF_LOG_ALL               (UINT32_MAX)
 #define DWARF_LOG_DEFAULT           (DWARF_LOG_DEBUG_INFO)
 
 class LogChannelDWARF : public lldb_private::LogChannel
 {
 public:
     LogChannelDWARF ();
 
-    virtual
-    ~LogChannelDWARF ();
+    ~LogChannelDWARF() override;
 
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     static lldb_private::LogChannel *
     CreateInstance ();
 
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
-    virtual void
-    Disable (const char** categories, lldb_private::Stream *feedback_strm);
+    void
+    Disable(const char** categories, lldb_private::Stream *feedback_strm) override;
 
     void
     Delete ();
 
-    virtual bool
-    Enable (lldb::StreamSP &log_stream_sp,
-            uint32_t log_options,
-            lldb_private::Stream *feedback_strm,      // Feedback stream for argument errors etc
-            const char **categories);    // The categories to enable within this logging stream, if empty, enable default set
+    bool
+    Enable(lldb::StreamSP &log_stream_sp,
+           lldb_private::Stream *feedback_strm,  // Feedback stream for argument errors etc
+           const char **categories) override;    // The categories to enable within this logging stream, if empty, enable default set
 
-    virtual void
-    ListCategories (lldb_private::Stream *strm);
+    void
+    ListCategories(lldb_private::Stream *strm) override;
 
     static lldb_private::Log *
     GetLog ();
 
     static lldb_private::Log *
     GetLogIfAll (uint32_t mask);
     
     static lldb_private::Log *
     GetLogIfAny (uint32_t mask);
     
     static void
     LogIf (uint32_t mask, const char *format, ...);
 };
 
-#endif  // SymbolFileDWARF_LogChannelDWARF_h_
+#endif // SymbolFileDWARF_LogChannelDWARF_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

-//===-- SymbolFileDWARFDebugMap.cpp ----------------------------*- C++ -*-===//
+//===-- SymbolFileDWARFDebugMap.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "SymbolFileDWARFDebugMap.h"
 
 #include "DWARFDebugAranges.h"
 
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"

 
 using namespace lldb;
 using namespace lldb_private;
 
 // Subclass lldb_private::Module so we can intercept the "Module::GetObjectFile()" 
 // (so we can fixup the object file sections) and also for "Module::GetSymbolVendor()"
 // (so we can fixup the symbol file id.
 
-
-
-
 const SymbolFileDWARFDebugMap::FileRangeMap &
 SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(SymbolFileDWARFDebugMap *exe_symfile)
 {
     if (file_range_map_valid)
         return file_range_map;
 
     file_range_map_valid = true;
 
if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos))
             exe_symfile->FinalizeOSOFileRanges (this);
             // We don't need the symbols anymore for the .o files
             oso_objfile->ClearSymtab();
         }
     }
     return file_range_map;
 }
 
-
 class DebugMapModule : public Module
 {
 public:
     DebugMapModule (const ModuleSP &exe_module_sp,
                     uint32_t cu_idx,
                     const FileSpec& file_spec,
                     const ArchSpec& arch,
                     const ConstString *object_name,
                     off_t object_offset,
                     const TimeValue *object_mod_time_ptr) :
         Module (file_spec, arch, object_name, object_offset, object_mod_time_ptr),
         m_exe_module_wp (exe_module_sp),
         m_cu_idx (cu_idx)
     {
     }
 
-    virtual
-    ~DebugMapModule ()
-    {
-    }
-
-    
-    virtual SymbolVendor*
-    GetSymbolVendor(bool can_create = true, lldb_private::Stream *feedback_strm = NULL)
+    ~DebugMapModule() override = default;
+    SymbolVendor*
+    GetSymbolVendor(bool can_create = true, lldb_private::Stream *feedback_strm = NULL) override
     {
         // Scope for locker
         if (m_symfile_ap.get() || can_create == false)
             return m_symfile_ap.get();
 
         ModuleSP exe_module_sp (m_exe_module_wp.lock());
         if (exe_module_sp)
         {

 }
 
 void
 SymbolFileDWARFDebugMap::Terminate()
 {
     PluginManager::UnregisterPlugin (CreateInstance);
 }
 
-
 lldb_private::ConstString
 SymbolFileDWARFDebugMap::GetPluginNameStatic()
 {
     static ConstString g_name("dwarf-debugmap");
     return g_name;
 }
 
 const char *
 SymbolFileDWARFDebugMap::GetPluginDescriptionStatic()
 {
     return "DWARF and DWARF3 debug symbol file reader (debug map).";
 }
 
 SymbolFile*
 SymbolFileDWARFDebugMap::CreateInstance (ObjectFile* obj_file)
 {
     return new SymbolFileDWARFDebugMap (obj_file);
 }
 
-
 SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap (ObjectFile* ofile) :
     SymbolFile(ofile),
     m_flags(),
     m_compile_unit_infos(),
     m_func_indexes(),
     m_glob_indexes(),
     m_supports_DW_AT_APPLE_objc_complete_type (eLazyBoolCalculate)
 {
 }
 
-
 SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap()
 {
 }
 
 void
 SymbolFileDWARFDebugMap::InitializeObject()
 {
 }
if (!comp_unit_info->oso_sp)
                                                                          oso_object ? &comp_unit_info->oso_mod_time : NULL));
         }
     }
     if (comp_unit_info->oso_sp)
         return comp_unit_info->oso_sp->module_sp.get();
     return NULL;
 }
 
-
 bool
 SymbolFileDWARFDebugMap::GetFileSpecForSO (uint32_t oso_idx, FileSpec &file_spec)
 {
     if (oso_idx < m_compile_unit_infos.size())
     {
         if (m_compile_unit_infos[oso_idx].so_file)
         {
             file_spec = m_compile_unit_infos[oso_idx].so_file;
             return true;
         }
     }
     return false;
 }
 
-
-
 ObjectFile *
 SymbolFileDWARFDebugMap::GetObjectFileByOSOIndex (uint32_t oso_idx)
 {
     Module *oso_module = GetModuleByOSOIndex (oso_idx);
     if (oso_module)
         return oso_module->GetObjectFile();
     return NULL;
 }

 SymbolFileDWARFDebugMap::GetObjectFileByCompUnitInfo (CompileUnitInfo *comp_unit_info)
 {
     Module *oso_module = GetModuleByCompUnitInfo (comp_unit_info);
     if (oso_module)
         return oso_module->GetObjectFile();
     return NULL;
 }
 
-
 uint32_t
 SymbolFileDWARFDebugMap::GetCompUnitInfoIndex (const CompileUnitInfo *comp_unit_info)
 {
     if (!m_compile_unit_infos.empty())
     {
         const CompileUnitInfo *first_comp_unit_info = &m_compile_unit_infos.front();
         const CompileUnitInfo *last_comp_unit_info = &m_compile_unit_infos.back();
         if (first_comp_unit_info <= comp_unit_info && comp_unit_info <= last_comp_unit_info)

 
 uint32_t
 SymbolFileDWARFDebugMap::GetNumCompileUnits()
 {
     InitOSO ();
     return m_compile_unit_infos.size();
 }
 
-
 CompUnitSP
 SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx)
 {
     CompUnitSP comp_unit_sp;
     const uint32_t cu_count = GetNumCompileUnits();
 
     if (cu_idx < cu_count)
     {
SymbolFileDWARFDebugMap::GetCompUnitInfo (const SymbolContext& sc)
     for (uint32_t i=0; i<cu_count; ++i)
     {
         if (sc.comp_unit == m_compile_unit_infos[i].compile_unit_sp.get())
             return &m_compile_unit_infos[i];
     }
     return NULL;
 }
 
-
 size_t
 SymbolFileDWARFDebugMap::GetCompUnitInfosForModule (const lldb_private::Module *module, std::vector<CompileUnitInfo *>& cu_infos)
 {
     const uint32_t cu_count = GetNumCompileUnits();
     for (uint32_t i=0; i<cu_count; ++i)
     {
         if (module == GetModuleByCompUnitInfo (&m_compile_unit_infos[i]))
             cu_infos.push_back (&m_compile_unit_infos[i]);

 SymbolFileDWARFDebugMap::ParseFunctionBlocks (const SymbolContext& sc)
 {
     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
     if (oso_dwarf)
         return oso_dwarf->ParseFunctionBlocks (sc);
     return 0;
 }
 
-
 size_t
 SymbolFileDWARFDebugMap::ParseTypes (const SymbolContext& sc)
 {
     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
     if (oso_dwarf)
         return oso_dwarf->ParseTypes (sc);
     return 0;
 }
 
-
 size_t
 SymbolFileDWARFDebugMap::ParseVariablesForContext (const SymbolContext& sc)
 {
     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
     if (oso_dwarf)
         return oso_dwarf->ParseVariablesForContext (sc);
     return 0;
 }
 
-
-
 Type*
 SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid)
 {
     const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
     SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
     if (oso_dwarf)
         return oso_dwarf->ResolveTypeUID (type_uid);
     return NULL;
if (symtab)
                     }
                 }
             }
         }
     }
     return resolved_flags;
 }
 
-
 uint32_t
 SymbolFileDWARFDebugMap::ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
 {
     const uint32_t initial = sc_list.GetSize();
     const uint32_t cu_count = GetNumCompileUnits();
 
     for (uint32_t i=0; i<cu_count; ++i)
     {
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
         
         return false;
     });
 
     // Return the number of variable that were appended to the list
     return variables.GetSize() - original_size;
 }
 
-
 uint32_t
 SymbolFileDWARFDebugMap::FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
 {
     // If we aren't appending the results to this list, then clear the list
     if (!append)
         variables.Clear();
 
     // Remember how many variables are in the list before we search in case
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
         
         return false;
     });
         
     // Return the number of variable that were appended to the list
     return variables.GetSize() - original_size;
 }
 
-
 int
 SymbolFileDWARFDebugMap::SymbolContainsSymbolWithIndex (uint32_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info)
 {
     const uint32_t symbol_idx = *symbol_idx_ptr;
 
     if (symbol_idx < comp_unit_info->first_symbol_index)
         return -1;
 
     if (symbol_idx <= comp_unit_info->last_symbol_index)
         return 0;
 
     return 1;
 }
 
-
 int
 SymbolFileDWARFDebugMap::SymbolContainsSymbolWithID (user_id_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info)
 {
     const user_id_t symbol_id = *symbol_idx_ptr;
 
     if (symbol_id < comp_unit_info->first_symbol_id)
         return -1;
 
     if (symbol_id <= comp_unit_info->last_symbol_id)
         return 0;
 
     return 1;
 }
 
-
 SymbolFileDWARFDebugMap::CompileUnitInfo*
 SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithIndex (uint32_t symbol_idx, uint32_t *oso_idx_ptr)
 {
     const uint32_t oso_index_count = m_compile_unit_infos.size();
     CompileUnitInfo *comp_unit_info = NULL;
     if (oso_index_count)
     {
         comp_unit_info = (CompileUnitInfo*)bsearch(&symbol_idx, 
if (oso_idx_ptr)
         if (comp_unit_info != NULL)
             *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
         else
             *oso_idx_ptr = UINT32_MAX;
     }
     return comp_unit_info;
 }
 
-
 static void
 RemoveFunctionsWithModuleNotEqualTo (const ModuleSP &module_sp, SymbolContextList &sc_list, uint32_t start_idx)
 {
     // We found functions in .o files. Not all functions in the .o files
     // will have made it into the final output file. The ones that did
     // make it into the final output file will have a section whose module
     // matches the module from the ObjectFile for this SymbolFile. When
     // the modules don't match, then we have something that was in a
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
             RemoveFunctionsWithModuleNotEqualTo (m_obj_file->GetModule(), sc_list, sc_idx);
         }
         return false;
     });
 
     return sc_list.GetSize() - initial_size;
 }
 
-
 uint32_t
 SymbolFileDWARFDebugMap::FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
 {
     Timer scoped_timer (__PRETTY_FUNCTION__,
                         "SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
                         regex.GetText());
 
     uint32_t initial_size = 0;

 size_t
 SymbolFileDWARFDebugMap::GetTypes (SymbolContextScope *sc_scope,
                                    uint32_t type_mask,
                                    TypeList &type_list)
 {
     Timer scoped_timer (__PRETTY_FUNCTION__,
                         "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)",
                         type_mask);
-    
-    
     uint32_t initial_size = type_list.GetSize();
     SymbolFileDWARF *oso_dwarf = NULL;
     if (sc_scope)
     {
         SymbolContext sc;
         sc_scope->CalculateSymbolContext(&sc);
         
         CompileUnitInfo *cu_info = GetCompUnitInfo (sc);
else
         ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
             oso_dwarf->GetTypes (sc_scope, type_mask, type_list);
             return false;
         });
     }
     return type_list.GetSize() - initial_size;
 }
 
-
 TypeSP
 SymbolFileDWARFDebugMap::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &die_decl_ctx)
 {
     TypeSP type_sp;
     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
         type_sp = oso_dwarf->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
         return ((bool)type_sp);
     });
     return type_sp;
 }
 
-
-
 bool
 SymbolFileDWARFDebugMap::Supports_DW_AT_APPLE_objc_complete_type (SymbolFileDWARF *skip_dwarf_oso)
 {
     if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate)
     {
         m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
         ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
             if (skip_dwarf_oso != oso_dwarf && oso_dwarf->Supports_DW_AT_APPLE_objc_complete_type(NULL))
if (oso_dwarf)
             {
                 return &m_compile_unit_infos[cu_idx];
             }
         }
     }
     return NULL;
 }
 
-
 void
 SymbolFileDWARFDebugMap::SetCompileUnit (SymbolFileDWARF *oso_dwarf, const CompUnitSP &cu_sp)
 {
     if (oso_dwarf)
     {
         const uint32_t cu_count = GetNumCompileUnits();
         for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
         {
if (debug_aranges && dwarf2Data)
                     debug_aranges->AppendRange(dwarf2Data->GetID(), entry->GetRangeBase(), entry->GetRangeEnd());
                     num_line_entries_added++;
                 }
             }
         }
     }
     return num_line_entries_added;
 }
-

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

 // Project includes
 #include "SymbolFileDWARF.h"
 
 class SymbolFileDWARFDwo : public SymbolFileDWARF
 {
 public:
     SymbolFileDWARFDwo(lldb::ObjectFileSP objfile, DWARFCompileUnit* dwarf_cu);
 
-    virtual
-    ~SymbolFileDWARFDwo() = default;
+    ~SymbolFileDWARFDwo() override = default;
     
     const lldb_private::DWARFDataExtractor&
     GetCachedSectionData(uint32_t got_flag,
                          lldb::SectionType sect_type,
                          lldb_private::DWARFDataExtractor &data) override;
     
     lldb::CompUnitSP
     ParseCompileUnit(DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) override;
protected:
 
     SymbolFileDWARF*
     GetBaseSymbolFile();
 
     lldb::ObjectFileSP m_obj_file_sp;
     DWARFCompileUnit* m_base_dwarf_cu;
 };
 
-#endif  // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_
+#endif // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

 //===-- SymbolFileSymtab.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_SymbolFileSymtab_h_
 #define liblldb_SymbolFileSymtab_h_
 
+// C Includes
+// C++ Includes
+#include <vector>
+
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Symtab.h"
-#include <vector>
 
 class SymbolFileSymtab : public lldb_private::SymbolFile
 {
 public:
     //------------------------------------------------------------------
+    // Constructors and Destructors
+    //------------------------------------------------------------------
+    SymbolFileSymtab(lldb_private::ObjectFile* obj_file);
+
+    ~SymbolFileSymtab() override;
+
+    //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     static lldb_private::SymbolFile*
     CreateInstance (lldb_private::ObjectFile* obj_file);
 
-    //------------------------------------------------------------------
-    // Constructors and Destructors
-    //------------------------------------------------------------------
-    SymbolFileSymtab(lldb_private::ObjectFile* obj_file);
-
-    virtual
-    ~SymbolFileSymtab();
-
-    virtual uint32_t        CalculateAbilities ();
+    uint32_t
+    CalculateAbilities() override;
 
     //------------------------------------------------------------------
     // Compile Unit function calls
     //------------------------------------------------------------------
-    virtual uint32_t
-    GetNumCompileUnits();
+    uint32_t
+    GetNumCompileUnits() override;
 
-    virtual lldb::CompUnitSP
-    ParseCompileUnitAtIndex(uint32_t index);
+    lldb::CompUnitSP
+    ParseCompileUnitAtIndex(uint32_t index) override;
 
-    virtual lldb::LanguageType
-    ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc);
+    lldb::LanguageType
+    ParseCompileUnitLanguage(const lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseCompileUnitFunctions(const lldb_private::SymbolContext& sc) override;
 
-    virtual bool
-    ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc);
+    bool
+    ParseCompileUnitLineTable(const lldb_private::SymbolContext& sc) override;
 
-    virtual bool
-    ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files);
+    bool
+    ParseCompileUnitSupportFiles(const lldb_private::SymbolContext& sc,
+                                 lldb_private::FileSpecList &support_files) override;
     
-    virtual bool
-    ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules);
+    bool
+    ParseImportedModules(const lldb_private::SymbolContext &sc,
+                         std::vector<lldb_private::ConstString> &imported_modules) override;
 
-    virtual size_t
-    ParseFunctionBlocks (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseFunctionBlocks(const lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    ParseTypes (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseTypes(const lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    ParseVariablesForContext (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseVariablesForContext(const lldb_private::SymbolContext& sc) override;
 
-    virtual lldb_private::Type*
-    ResolveTypeUID(lldb::user_id_t type_uid);
+    lldb_private::Type*
+    ResolveTypeUID(lldb::user_id_t type_uid) override;
 
-    virtual bool
-    CompleteType (lldb_private::CompilerType& compiler_type);
+    bool
+    CompleteType(lldb_private::CompilerType& compiler_type) override;
 
-    virtual uint32_t
-    ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc);
+    uint32_t
+    ResolveSymbolContext(const lldb_private::Address& so_addr,
+                         uint32_t resolve_scope,
+                         lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    GetTypes (lldb_private::SymbolContextScope *sc_scope,
-              uint32_t type_mask,
-              lldb_private::TypeList &type_list);
+    size_t
+    GetTypes(lldb_private::SymbolContextScope *sc_scope,
+             lldb_private::TypeList &type_list) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
 protected:
     typedef std::map<lldb_private::ConstString, lldb::TypeSP> TypeMap;
 
     lldb_private::Symtab::IndexCollection m_source_indexes;
     lldb_private::Symtab::IndexCollection m_func_indexes;
     lldb_private::Symtab::IndexCollection m_code_indexes;
     lldb_private::Symtab::IndexCollection m_data_indexes;
     lldb_private::Symtab::NameToIndexMap m_objc_class_name_to_index;
     TypeMap m_objc_class_types;
     
 private:
     DISALLOW_COPY_AND_ASSIGN (SymbolFileSymtab);
 };
 
-
-#endif  // liblldb_SymbolFileSymtab_h_
+#endif // liblldb_SymbolFileSymtab_h_

lldb/trunk/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.h

-//===-- SymbolVendorELF.h ------------------------------------*- C++ -*-===//
+//===-- SymbolVendorELF.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_SymbolVendorELF_h_
 #define liblldb_SymbolVendorELF_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Symbol/SymbolVendor.h"
 
 class SymbolVendorELF : public lldb_private::SymbolVendor
 {
 public:
     //------------------------------------------------------------------
+    // Constructors and Destructors
+    //------------------------------------------------------------------
+    SymbolVendorELF (const lldb::ModuleSP &module_sp);
+
+    ~SymbolVendorELF() override;
+
+    //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     static lldb_private::SymbolVendor*
     CreateInstance (const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm);
 
     //------------------------------------------------------------------
-    // Constructors and Destructors
-    //------------------------------------------------------------------
-    SymbolVendorELF (const lldb::ModuleSP &module_sp);
-
-    virtual
-    ~SymbolVendorELF();
-
-    //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (SymbolVendorELF);
 };
 
-#endif  // liblldb_SymbolVendorELF_h_
+#endif // liblldb_SymbolVendorELF_h_