[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.

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h

 #ifndef liblldb_DisassemblerLLVMC_h_
 #define liblldb_DisassemblerLLVMC_h_
 
+// C Includes
+// C++ Includes
 #include <string>
 
+// Other libraries and framework includes
 #include "llvm-c/Disassembler.h"
 
+// Project includes
+#include "lldb/Core/Address.h"
+#include "lldb/Core/Disassembler.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Host/Mutex.h"
+
 // Opaque references to C++ Objects in LLVM's MC.
 namespace llvm
 {

     class MCInstPrinter;
     class MCAsmInfo;
     class MCSubtargetInfo;
-}
+} // namespace llvm
 
-#include "lldb/Core/Address.h"
-#include "lldb/Core/Disassembler.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Host/Mutex.h"
-
 class InstructionLLVMC;
 
 class DisassemblerLLVMC : public lldb_private::Disassembler

     public:
         LLVMCDisassembler (const char *triple, const char *cpu, const char *features_str, unsigned flavor, DisassemblerLLVMC &owner);
 
-        ~LLVMCDisassembler();
+        ~LLVMCDisassembler() = default;
 
         uint64_t GetMCInst (const uint8_t *opcode_data, size_t opcode_data_len, lldb::addr_t pc, llvm::MCInst &mc_inst);
         uint64_t PrintMCInst (llvm::MCInst &mc_inst, char *output_buffer, size_t out_buffer_len);

     };
 
 public:
+    DisassemblerLLVMC(const lldb_private::ArchSpec &arch, const char *flavor /* = NULL */);
+
+    ~DisassemblerLLVMC() override = default;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------

     static lldb_private::Disassembler *
     CreateInstance(const lldb_private::ArchSpec &arch, const char *flavor);
 
-    DisassemblerLLVMC(const lldb_private::ArchSpec &arch, const char *flavor /* = NULL */);
+    size_t
+    DecodeInstructions(const lldb_private::Address &base_addr,
+                       const lldb_private::DataExtractor& data,
+                       lldb::offset_t data_offset,
+                       size_t num_instructions,
+                       bool append,
+                       bool data_from_file) override;
 
-    virtual
-    ~DisassemblerLLVMC();
-
-    virtual size_t
-    DecodeInstructions (const lldb_private::Address &base_addr,
-                        const lldb_private::DataExtractor& data,
-                        lldb::offset_t data_offset,
-                        size_t num_instructions,
-                        bool append,
-                        bool data_from_file);
-
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
 protected:
     friend class InstructionLLVMC;
 
-    virtual bool
-    FlavorValidForArchSpec (const lldb_private::ArchSpec &arch, const char *flavor);
+    bool
+    FlavorValidForArchSpec(const lldb_private::ArchSpec &arch, const char *flavor) override;
 
     bool
     IsValid()

     std::unique_ptr<LLVMCDisassembler> m_alternate_disasm_ap;
 };
 
-#endif  // liblldb_DisassemblerLLVM_h_
+#endif // liblldb_DisassemblerLLVM_h_

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "DisassemblerLLVMC.h"
-
+// C Includes
+// C++ Includes
+// Project includes
 #include "llvm-c/Disassembler.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"

 #include "llvm/Support/TargetSelect.h"
 #include "llvm/ADT/SmallString.h"
 
+// Other libraries and framework includes
+#include "DisassemblerLLVMC.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/DataExtractor.h"

     {
     }
 
-    virtual
-    ~InstructionLLVMC ()
-    {
-    }
+    ~InstructionLLVMC() override = default;
 
-    virtual bool
-    DoesBranch ()
+    bool
+    DoesBranch() override
     {
         if (m_does_branch == eLazyBoolCalculate)
         {

         return m_does_branch == eLazyBoolYes;
     }
 
-    virtual bool
-    HasDelaySlot ()
+    bool
+    HasDelaySlot() override
     {
         if (m_has_delay_slot == eLazyBoolCalculate)
         {

         return llvm_disasm.m_disasm_ap.get();
     }
 
-    virtual size_t
-    Decode (const lldb_private::Disassembler &disassembler,
-            const lldb_private::DataExtractor &data,
-            lldb::offset_t data_offset)
+    size_t
+    Decode(const lldb_private::Disassembler &disassembler,
+           lldb::offset_t data_offset) override
     {
         // All we have to do is read the opcode which can be easy for some
         // architectures

         }
     }
 
-    virtual void
-    CalculateMnemonicOperandsAndComment (const lldb_private::ExecutionContext *exe_ctx)
+    void
+    CalculateMnemonicOperandsAndComment(const lldb_private::ExecutionContext *exe_ctx) override
     {
         DataExtractor data;
         const AddressClass address_class = GetAddressClass ();

     bool                    m_using_file_addr;
 };
 
-
-
 DisassemblerLLVMC::LLVMCDisassembler::LLVMCDisassembler (const char *triple, const char *cpu, const char *features_str, unsigned flavor, DisassemblerLLVMC &owner):
     m_is_valid(true)
 {

         m_is_valid = false;
 }
 
-DisassemblerLLVMC::LLVMCDisassembler::~LLVMCDisassembler()
-{
-}
-
 uint64_t
 DisassemblerLLVMC::LLVMCDisassembler::GetMCInst (const uint8_t *opcode_data,
                                                  size_t opcode_data_len,

         return false;
 }
 
-
 Disassembler *
 DisassemblerLLVMC::CreateInstance (const ArchSpec &arch, const char *flavor)
 {

     }
 }
 
-DisassemblerLLVMC::~DisassemblerLLVMC()
-{
-}
-
 size_t
 DisassemblerLLVMC::DecodeInstructions (const Address &base_addr,
                                        const DataExtractor& data,

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h

 
 // C Includes
 // C++ Includes
-#include <map>
 #include <vector>
 #include <string>
 
 // Other libraries and framework includes
-
+// Project includes
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/TimeValue.h"

 class DynamicLoaderDarwinKernel : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderDarwinKernel(lldb_private::Process *process, lldb::addr_t kernel_addr);
+
+    ~DynamicLoaderDarwinKernel() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------

     static void
     DebuggerInitialize (lldb_private::Debugger &debugger);
 
-    DynamicLoaderDarwinKernel (lldb_private::Process *process, lldb::addr_t kernel_addr);
-
-    virtual
-    ~DynamicLoaderDarwinKernel ();
-
     //------------------------------------------------------------------
     /// Called after attaching a process.
     ///
     /// Allow DynamicLoader plug-ins to execute some code after
     /// attaching to a process.
     //------------------------------------------------------------------
-    virtual void
-    DidAttach ();
+    void
+    DidAttach() override;
 
-    virtual void
-    DidLaunch ();
+    void
+    DidLaunch() override;
 
-    virtual lldb::ThreadPlanSP
-    GetStepThroughTrampolinePlan (lldb_private::Thread &thread,
-                                  bool stop_others);
+    lldb::ThreadPlanSP
+    GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
+                                 bool stop_others) override;
 
-    virtual lldb_private::Error
-    CanLoadImage ();
+    lldb_private::Error
+    CanLoadImage() override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
 protected:
     void

         lldb::addr_t             m_load_address;
         uint64_t                 m_size;
         bool                     m_kernel_image;         // true if this is the kernel, false if this is a kext
-
     };
 
     struct OSKextLoadedKextSummaryHeader

     DISALLOW_COPY_AND_ASSIGN (DynamicLoaderDarwinKernel);
 };
 
-#endif  // liblldb_DynamicLoaderDarwinKernel_h_
+#endif // liblldb_DynamicLoaderDarwinKernel_h_

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h

 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_DynamicLoaderHexagon_H_
-#define liblldb_DynamicLoaderHexagon_H_
+#ifndef liblldb_DynamicLoaderHexagonDYLD_h_
+#define liblldb_DynamicLoaderHexagonDYLD_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
+// Project includes
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Target/DynamicLoader.h"
 

 class DynamicLoaderHexagonDYLD : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderHexagonDYLD(lldb_private::Process *process);
 
+    ~DynamicLoaderHexagonDYLD() override;
+
     static void
     Initialize();
 

     static lldb_private::DynamicLoader *
     CreateInstance(lldb_private::Process *process, bool force);
 
-    DynamicLoaderHexagonDYLD(lldb_private::Process *process);
-
-    virtual
-    ~DynamicLoaderHexagonDYLD();
-
     //------------------------------------------------------------------
     // DynamicLoader protocol
     //------------------------------------------------------------------
 
-    virtual void
+    void
     DidAttach() override;
 
-    virtual void
+    void
     DidLaunch() override;
 
     lldb::ThreadPlanSP
     GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
                                  bool stop_others) override;
 
-    virtual lldb_private::Error
+    lldb_private::Error
     CanLoadImage() override;
 
-    virtual lldb::addr_t
-    GetThreadLocalData (const lldb::ModuleSP module, const lldb::ThreadSP thread) override;
+    lldb::addr_t
+    GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
+    lldb_private::ConstString
     GetPluginName() override;
 
-    virtual uint32_t
+    uint32_t
     GetPluginVersion() override;
 
 protected:

     FindRendezvousBreakpointAddress( );
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(DynamicLoaderHexagonDYLD);
-
     const lldb_private::SectionList *
     GetSectionListFromModule(const lldb::ModuleSP module) const;
+
+    DISALLOW_COPY_AND_ASSIGN(DynamicLoaderHexagonDYLD);
 };
 
-#endif  // liblldb_DynamicLoaderHexagonDYLD_H_
+#endif // liblldb_DynamicLoaderHexagonDYLD_h_

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

 
 // C Includes
 // C++ Includes
-#include <map>
 #include <vector>
-#include <string>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
-
-// Other libraries and framework includes
 #include "lldb/Utility/SafeMachO.h"
 
 class DynamicLoaderMacOSXDYLD : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderMacOSXDYLD(lldb_private::Process *process);
+
+    ~DynamicLoaderMacOSXDYLD() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------

     static lldb_private::DynamicLoader *
     CreateInstance (lldb_private::Process *process, bool force);
 
-    DynamicLoaderMacOSXDYLD (lldb_private::Process *process);
-
-    virtual
-    ~DynamicLoaderMacOSXDYLD ();
     //------------------------------------------------------------------
     /// Called after attaching a process.
     ///
     /// Allow DynamicLoader plug-ins to execute some code after
     /// attaching to a process.
     //------------------------------------------------------------------
-    virtual void
-    DidAttach ();
+    void
+    DidAttach() override;
 
-    virtual void
-    DidLaunch ();
+    void
+    DidLaunch() override;
 
-    virtual bool
-    ProcessDidExec ();
+    bool
+    ProcessDidExec() override;
 
-    virtual lldb::ThreadPlanSP
-    GetStepThroughTrampolinePlan (lldb_private::Thread &thread,
-                                  bool stop_others);
+    lldb::ThreadPlanSP
+    GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
+                                 bool stop_others) override;
 
-    virtual size_t
-    FindEquivalentSymbols (lldb_private::Symbol *original_symbol, 
-                           lldb_private::ModuleList &module_list, 
-                           lldb_private::SymbolContextList &equivalent_symbols);
+    size_t
+    FindEquivalentSymbols(lldb_private::Symbol *original_symbol,
+                          lldb_private::ModuleList &module_list,
+                          lldb_private::SymbolContextList &equivalent_symbols) override;
     
-    virtual lldb_private::Error
-    CanLoadImage ();
+    lldb_private::Error
+    CanLoadImage() override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
-    virtual bool
-    AlwaysRelyOnEHUnwindInfo (lldb_private::SymbolContext &sym_ctx);
+    bool
+    AlwaysRelyOnEHUnwindInfo(lldb_private::SymbolContext &sym_ctx) override;
 
 protected:
     void

     void
     PrivateProcessStateChanged (lldb_private::Process *process,
                                 lldb::StateType state);
+
     bool
     LocateDYLD ();
 

     ReadMachHeader (lldb::addr_t addr,
                     llvm::MachO::mach_header *header,
                     lldb_private::DataExtractor *load_command_data);
+
     class Segment
     {
     public:
-
         Segment() :
             name(),
             vmaddr(LLDB_INVALID_ADDRESS),

     DISALLOW_COPY_AND_ASSIGN (DynamicLoaderMacOSXDYLD);
 };
 
-#endif  // liblldb_DynamicLoaderMacOSXDYLD_h_
+#endif // liblldb_DynamicLoaderMacOSXDYLD_h_

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

-//===-- DynamicLoaderPOSIX.h ------------------------------------*- C++ -*-===//
+//===-- DynamicLoaderPOSIXDYLD.h --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_DynamicLoaderPOSIX_H_
-#define liblldb_DynamicLoaderPOSIX_H_
+#ifndef liblldb_DynamicLoaderPOSIXDYLD_h_
+#define liblldb_DynamicLoaderPOSIXDYLD_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
+// Project includes
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Target/DynamicLoader.h"
 

 class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderPOSIXDYLD(lldb_private::Process *process);
 
+    ~DynamicLoaderPOSIXDYLD() override;
+
     static void
     Initialize();
 

     static lldb_private::DynamicLoader *
     CreateInstance(lldb_private::Process *process, bool force);
 
-    DynamicLoaderPOSIXDYLD(lldb_private::Process *process);
-
-    virtual
-    ~DynamicLoaderPOSIXDYLD();
-
     //------------------------------------------------------------------
     // DynamicLoader protocol
     //------------------------------------------------------------------
 
-    virtual void
+    void
     DidAttach() override;
 
-    virtual void
+    void
     DidLaunch() override;
 
     lldb::ThreadPlanSP
     GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
                                  bool stop_others) override;
 
-    virtual lldb_private::Error
+    lldb_private::Error
     CanLoadImage() override;
 
-    virtual lldb::addr_t
-    GetThreadLocalData (const lldb::ModuleSP module, const lldb::ThreadSP thread) override;
+    lldb::addr_t
+    GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
+    lldb_private::ConstString
     GetPluginName() override;
 
-    virtual uint32_t
+    uint32_t
     GetPluginVersion() override;
 
 protected:

     DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
 };
 
-#endif  // liblldb_DynamicLoaderPOSIXDYLD_H_
+#endif // liblldb_DynamicLoaderPOSIXDYLD_h_

source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h

 
 // C Includes
 // C++ Includes
-#include <map>
-#include <vector>
-#include <string>
-
 // Other libraries and framework includes
-
+// Project includes
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Core/UUID.h"

 class DynamicLoaderStatic : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderStatic(lldb_private::Process *process);
+
+    ~DynamicLoaderStatic() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------

     static lldb_private::DynamicLoader *
     CreateInstance (lldb_private::Process *process, bool force);
 
-    DynamicLoaderStatic (lldb_private::Process *process);
-
-    virtual
-    ~DynamicLoaderStatic ();
     //------------------------------------------------------------------
     /// Called after attaching a process.
     ///
     /// Allow DynamicLoader plug-ins to execute some code after
     /// attaching to a process.
     //------------------------------------------------------------------
-    virtual void
-    DidAttach ();
+    void
+    DidAttach() override;
 
-    virtual void
-    DidLaunch ();
+    void
+    DidLaunch() override;
 
-    virtual lldb::ThreadPlanSP
-    GetStepThroughTrampolinePlan (lldb_private::Thread &thread,
-                                  bool stop_others);
+    lldb::ThreadPlanSP
+    GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
+                                 bool stop_others) override;
 
-    virtual lldb_private::Error
-    CanLoadImage ();
+    lldb_private::Error
+    CanLoadImage() override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
 private:
     void

     DISALLOW_COPY_AND_ASSIGN (DynamicLoaderStatic);
 };
 
-#endif  // liblldb_DynamicLoaderStatic_h_
+#endif // liblldb_DynamicLoaderStatic_h_

source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h

-//===-- DynamicLoaderWindowsDYLDh ----------------------------------*- C++ -*-===//
+//===-- DynamicLoaderWindowsDYLD.h ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_H_
-#define liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_H_
+#ifndef liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_h_
+#define liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-forward.h"
 #include "lldb/Target/DynamicLoader.h"
 

 
 class DynamicLoaderWindowsDYLD : public DynamicLoader
 {
-  public:
+    DynamicLoaderWindowsDYLD(Process *process);
+
+    ~DynamicLoaderWindowsDYLD() override;
+
     static void Initialize();
     static void Terminate();
     static ConstString GetPluginNameStatic();
     static const char *GetPluginDescriptionStatic();
 
-    DynamicLoaderWindowsDYLD(Process *process);
-    virtual ~DynamicLoaderWindowsDYLD();
-
     static DynamicLoader *CreateInstance(Process *process, bool force);
 
     void DidAttach() override;

     ConstString GetPluginName() override;
     uint32_t GetPluginVersion() override;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_h_

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "ClangExpressionParser.h"
-
-#include "ClangASTSource.h"
-#include "ClangExpressionHelper.h"
-#include "ClangExpressionDeclMap.h"
-#include "ClangModulesDeclVendor.h"
-#include "ClangPersistentVariables.h"
-#include "IRForTarget.h"
-
-#include "lldb/Core/ArchSpec.h"
-#include "lldb/Core/DataBufferHeap.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/Disassembler.h"
-#include "lldb/Core/Log.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/Stream.h"
-#include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StreamString.h"
-#include "lldb/Expression/IRExecutionUnit.h"
-#include "lldb/Expression/IRDynamicChecks.h"
-#include "lldb/Expression/IRInterpreter.h"
-#include "lldb/Host/File.h"
-#include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Symbol/SymbolVendor.h"
-#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
-
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/Basic/FileManager.h"

 #include "llvm/Support/Host.h"
 #include "llvm/Support/Signals.h"
 
+// Project includes
+#include "ClangExpressionParser.h"
+
+#include "ClangASTSource.h"
+#include "ClangExpressionHelper.h"
+#include "ClangExpressionDeclMap.h"
+#include "ClangModulesDeclVendor.h"
+#include "ClangPersistentVariables.h"
+#include "IRForTarget.h"
+
+#include "lldb/Core/ArchSpec.h"
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Disassembler.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Expression/IRExecutionUnit.h"
+#include "lldb/Expression/IRDynamicChecks.h"
+#include "lldb/Expression/IRInterpreter.h"
+#include "lldb/Host/File.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
 using namespace clang;
 using namespace llvm;
 using namespace lldb_private;

     ClangPersistentVariables   &m_persistent_vars;
     StreamString                m_error_stream;
     bool                        m_has_errors = false;
+
 public:
     LLDBPreprocessorCallbacks(ClangModulesDeclVendor &decl_vendor,
                               ClangPersistentVariables &persistent_vars) :

     {
     }
     
-    virtual void moduleImport(SourceLocation import_location,
-                              clang::ModuleIdPath path,
-                              const clang::Module * /*null*/)
+    void
+    moduleImport(SourceLocation import_location,
+                 clang::ModuleIdPath path,
+                 const clang::Module * /*null*/) override
     {
         std::vector<ConstString> string_path;
         

source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h

-//===-- ClangFunctionCaller.h -----------------------------------------*- C++ -*-===//
+//===-- ClangFunctionCaller.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 
 // C Includes
 // C++ Includes
-#include <vector>
-#include <list>
 // Other libraries and framework includes
 // Project includes
 #include "ClangExpressionHelper.h"

         {
         }
         
-        ~ClangFunctionCallerHelper() {}
+        ~ClangFunctionCallerHelper() override = default;
         
         //------------------------------------------------------------------
         /// Return the object that the parser should use when resolving external

         //------------------------------------------------------------------
         clang::ASTConsumer *
         ASTTransformer(clang::ASTConsumer *passthrough) override;
+
     private:
         ClangFunctionCaller                      &m_owner;
         std::unique_ptr<ASTStructExtractor> m_struct_extractor;         ///< The class that generates the argument struct layout.

                          const ValueList &arg_value_list,
                          const char *name);
     
-    //------------------------------------------------------------------
-    /// Destructor
-    //------------------------------------------------------------------
     ~ClangFunctionCaller() override;
 
     //------------------------------------------------------------------

     {
         return &m_type_system_helper;
     }
+
 protected:
     const char *GetWrapperStructName()
     {
         return m_wrapper_struct_name.c_str();
     }
+
 private:
     //------------------------------------------------------------------
     // For ClangFunctionCaller only

     // Note: the parser needs to be destructed before the execution unit, so
     // declare the execution unit first.
     ClangFunctionCallerHelper   m_type_system_helper;
-
 };
 
-} // Namespace lldb_private
+} // namespace lldb_private
 
 #endif // liblldb_ClangFunctionCaller_h_

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include <mutex> // std::once
+// C Includes
+// C++ Includes
+#include <mutex>
 
+// Other libraries and framework includes
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Parse/Parser.h"
+#include "clang/Sema/Lookup.h"
+#include "clang/Serialization/ASTReader.h"
+
+// Project includes
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/Log.h"

 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 
-#include "clang/Basic/TargetInfo.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendActions.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Parse/Parser.h"
-#include "clang/Sema/Lookup.h"
-#include "clang/Serialization/ASTReader.h"
-
-
 using namespace lldb_private;
 
 namespace {

     {
     public:
         StoringDiagnosticConsumer ();
+
         void
-        HandleDiagnostic (clang::DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info);
+        HandleDiagnostic(clang::DiagnosticsEngine::Level DiagLevel,
+                         const clang::Diagnostic &info) override;
         
         void
         ClearDiagnostics ();
         
         void
         DumpDiagnostics (Stream &error_stream);
+
     private:
         typedef std::pair<clang::DiagnosticsEngine::Level, std::string> IDAndDiagnostic;
         std::vector<IDAndDiagnostic> m_diagnostics;

                                    llvm::IntrusiveRefCntPtr<clang::CompilerInvocation> &compiler_invocation,
                                    std::unique_ptr<clang::CompilerInstance> &&compiler_instance,
                                    std::unique_ptr<clang::Parser> &&parser);
-        
-        virtual bool
+        ~ClangModulesDeclVendorImpl() override = default;
+
+        bool
         AddModule(ModulePath &path,
                   ModuleVector *exported_modules,
                   Stream &error_stream) override;
-        
-        virtual bool
+        bool
         AddModulesForCompileUnit(CompileUnit &cu,
                                  ModuleVector &exported_modules,
                                  Stream &error_stream) override;
+
+        uint32_t
+        FindDecls(const ConstString &name,
+                  bool append,
+                  uint32_t max_matches,
+                  std::vector <clang::NamedDecl*> &decls) override;
         
-        virtual uint32_t
-        FindDecls (const ConstString &name,
-                   bool append,
-                   uint32_t max_matches,
-                   std::vector <clang::NamedDecl*> &decls) override;
-        
-        virtual void
+        void
         ForEachMacro(const ModuleVector &modules,
                      std::function<bool (const std::string &)> handler) override;
         
-        ~ClangModulesDeclVendorImpl();
-        
     private:
         void
         ReportModuleExportsHelper (std::set<ClangModulesDeclVendor::ModuleID> &exports,

         ImportedModuleMap                                   m_imported_modules;
         ImportedModuleSet                                   m_user_imported_modules;
     };
-}
+} // anonymous namespace
 
 StoringDiagnosticConsumer::StoringDiagnosticConsumer ()
 {

     return g_cached_resource_dir;
 }
 
-
 ClangModulesDeclVendor::ClangModulesDeclVendor()
 {
 }

     return false;
 }
 
-
 bool
 ClangModulesDeclVendor::LanguageSupportsClangModules (lldb::LanguageType language)
 {

     }
 }
 
-ClangModulesDeclVendorImpl::~ClangModulesDeclVendorImpl()
-{
-}
-
 clang::ModuleLoadResult
 ClangModulesDeclVendorImpl::DoGetModule(clang::ModuleIdPath path,
                                         bool make_visible)

source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h

 #ifndef liblldb_ClangPersistentVariables_h_
 #define liblldb_ClangPersistentVariables_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+#include "llvm/ADT/DenseMap.h"
+
+// Project includes
 #include "ClangExpressionVariable.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Expression/ExpressionVariable.h"
 
-#include "llvm/ADT/DenseMap.h"
-
 namespace lldb_private
 {
     

 class ClangPersistentVariables : public PersistentExpressionState
 {
 public:
-    
-    //----------------------------------------------------------------------
-    /// Constructor
-    //----------------------------------------------------------------------
-    ClangPersistentVariables ();
-    
-    ~ClangPersistentVariables () { }
-    
+    ClangPersistentVariables();
+
+    ~ClangPersistentVariables() override = default;
+
     //------------------------------------------------------------------
     // llvm casting support
     //------------------------------------------------------------------

                                                                                             ///< priority source for macros.
 };
 
-}
+} // namespace lldb_private
 
-#endif
+#endif // liblldb_ClangPersistentVariables_h_

source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

 
 // C Includes
 // C++ Includes
-#include <string>
-#include <map>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-
 #include "ASTStructExtractor.h"
 #include "ASTResultSynthesizer.h"
 #include "ClangExpressionDeclMap.h"

 class ClangUserExpression : public UserExpression
 {
 public:
-
     enum { kDefaultTimeout = 500000u };
 
-
     class ClangUserExpressionHelper : public ClangExpressionHelper
     {
     public:

         {
         }
         
-        ~ClangUserExpressionHelper() {}
+        ~ClangUserExpressionHelper() override = default;
         
         //------------------------------------------------------------------
         /// Return the object that the parser should use when resolving external

         //------------------------------------------------------------------
         clang::ASTConsumer *
         ASTTransformer(clang::ASTConsumer *passthrough) override;
+
     private:
         Target                                  &m_target;
         std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up;

                          lldb::LanguageType language,
                          ResultType desired_type);
 
-    //------------------------------------------------------------------
-    /// Destructor
-    //------------------------------------------------------------------
     ~ClangUserExpression() override;
 
     //------------------------------------------------------------------

         
         void RegisterPersistentState(PersistentExpressionState *persistent_state);
         lldb::ExpressionVariableSP &GetVariable();
+
     private:
         PersistentExpressionState *m_persistent_state;
         lldb::ExpressionVariableSP m_variable;

source/Plugins/Instruction/ARM64/EmulateInstructionARM64.h

-//===-- EmulateInstructionARM64.h ------------------------------------*- C++ -*-===//
+//===-- EmulateInstructionARM64.h -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 #ifndef EmulateInstructionARM64_h_
 #define EmulateInstructionARM64_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Interpreter/OptionValue.h"

 class EmulateInstructionARM64 : public lldb_private::EmulateInstruction
 {
 public: 
+    EmulateInstructionARM64 (const lldb_private::ArchSpec &arch) :
+        EmulateInstruction (arch),
+        m_opcode_pstate (),
+        m_emulated_pstate (),
+        m_ignore_conditions (false)
+    {
+    }
+
     static void
     Initialize ();
     

         return false;
     }
 
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion()
+    uint32_t
+    GetPluginVersion() override
     {
         return 1;
     }
 
     bool
-    SetTargetTriple (const lldb_private::ArchSpec &arch);
+    SetTargetTriple(const lldb_private::ArchSpec &arch) override;
     
-    EmulateInstructionARM64 (const lldb_private::ArchSpec &arch) :
-        EmulateInstruction (arch),
-        m_opcode_pstate (),
-        m_emulated_pstate (),
-        m_ignore_conditions (false)
+    bool
+    SupportsEmulatingInstructionsOfType(lldb_private::InstructionType inst_type) override
     {
-    }
-
-    virtual bool
-    SupportsEmulatingInstructionsOfType (lldb_private::InstructionType inst_type)
-    {
         return SupportsEmulatingInstructionsOfTypeStatic (inst_type);
     }
 
-    virtual bool 
-    ReadInstruction ();
+    bool
+    ReadInstruction() override;
     
-    virtual bool
-    EvaluateInstruction (uint32_t evaluate_options);
+    bool
+    EvaluateInstruction(uint32_t evaluate_options) override;
     
-    virtual bool
-    TestEmulation (lldb_private::Stream *out_stream, 
-                   lldb_private::ArchSpec &arch, 
-                   lldb_private::OptionValueDictionary *test_data)
+    bool
+    TestEmulation(lldb_private::Stream *out_stream,
+                  lldb_private::ArchSpec &arch,
+                  lldb_private::OptionValueDictionary *test_data) override
     {
         return false;
     }
 
-    virtual bool
-    GetRegisterInfo (lldb::RegisterKind reg_kind,
-                     uint32_t reg_num, 
-                     lldb_private::RegisterInfo &reg_info);
+    bool
+    GetRegisterInfo(lldb::RegisterKind reg_kind,
+                    uint32_t reg_num,
+                    lldb_private::RegisterInfo &reg_info) override;
 
-    virtual bool
-    CreateFunctionEntryUnwind (lldb_private::UnwindPlan &unwind_plan);
+    bool
+    CreateFunctionEntryUnwind(lldb_private::UnwindPlan &unwind_plan) override;
 
-    
     typedef enum 
     {
         AddrMode_OFF, 

         BitwiseOp_NOT, 
         BitwiseOp_RBIT
     } BitwiseOp;
-    
 
     typedef enum
     {

     } ProcState;
 
 protected:
-
     typedef struct
     {
         uint32_t mask;

     bool m_ignore_conditions;
 };
 
-#endif  // EmulateInstructionARM64_h_
+#endif // EmulateInstructionARM64_h_

source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h

-//===-- EmulateInstructionMIPS64.h ------------------------------------*- C++ -*-===//
+//===-- EmulateInstructionMIPS64.h ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 #ifndef EmulateInstructionMIPS64_h_
 #define EmulateInstructionMIPS64_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/EmulateInstruction.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Interpreter/OptionValue.h"
+
 namespace llvm
 {
     class MCDisassembler;

     class MCContext;
     class MCInstrInfo;
     class MCInst;
-}
+} // namespace llvm
 
-#include "lldb/Core/EmulateInstruction.h"
-#include "lldb/Core/Error.h"
-#include "lldb/Interpreter/OptionValue.h"
-
 class EmulateInstructionMIPS64 : public lldb_private::EmulateInstruction
 {
 public: 
+    EmulateInstructionMIPS64(const lldb_private::ArchSpec &arch);
+
     static void
     Initialize ();
 

         return false;
     }
 
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion()
+    uint32_t
+    GetPluginVersion() override
     {
         return 1;
     }
 
     bool
-    SetTargetTriple (const lldb_private::ArchSpec &arch);
+    SetTargetTriple(const lldb_private::ArchSpec &arch) override;
     
-    EmulateInstructionMIPS64 (const lldb_private::ArchSpec &arch);
-
-    virtual bool
-    SupportsEmulatingInstructionsOfType (lldb_private::InstructionType inst_type)
+    bool
+    SupportsEmulatingInstructionsOfType(lldb_private::InstructionType inst_type) override
     {
         return SupportsEmulatingInstructionsOfTypeStatic (inst_type);
     }
 
-    virtual bool 
-    ReadInstruction ();
+    bool
+    ReadInstruction() override;
     
-    virtual bool
-    EvaluateInstruction (uint32_t evaluate_options);
+    bool
+    EvaluateInstruction(uint32_t evaluate_options) override;
     
-    virtual bool
-    TestEmulation (lldb_private::Stream *out_stream, 
-                   lldb_private::ArchSpec &arch, 
-                   lldb_private::OptionValueDictionary *test_data)
+    bool
+    TestEmulation(lldb_private::Stream *out_stream,
+                  lldb_private::ArchSpec &arch,
+                  lldb_private::OptionValueDictionary *test_data) override
     {
         return false;
     }
 
-    virtual bool
-    GetRegisterInfo (lldb::RegisterKind reg_kind,
-                     uint32_t reg_num, 
-                     lldb_private::RegisterInfo &reg_info);
+    bool
+    GetRegisterInfo(lldb::RegisterKind reg_kind,
+                    uint32_t reg_num,
+                    lldb_private::RegisterInfo &reg_info) override;
 
-    virtual bool
-    CreateFunctionEntryUnwind (lldb_private::UnwindPlan &unwind_plan);
+    bool
+    CreateFunctionEntryUnwind(lldb_private::UnwindPlan &unwind_plan) override;
 
-
 protected:
-
     typedef struct
     {
         const char *op_name;

     std::unique_ptr<llvm::MCInstrInfo>      m_insn_info;
 };
 
-#endif  // EmulateInstructionMIPS64_h_
+#endif // EmulateInstructionMIPS64_h_

source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h

 #ifndef liblldb_AddressSanitizerRuntime_h_
 #define liblldb_AddressSanitizerRuntime_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/InstrumentationRuntime.h"

 class AddressSanitizerRuntime : public lldb_private::InstrumentationRuntime
 {
 public:
-    
+    ~AddressSanitizerRuntime() override;
+
     static lldb::InstrumentationRuntimeSP
     CreateInstance (const lldb::ProcessSP &process_sp);
     

     
     static lldb::InstrumentationRuntimeType
     GetTypeStatic();
+
+    lldb_private::ConstString
+    GetPluginName() override
+    { 
+        return GetPluginNameStatic();
+    }
     
-    virtual
-    ~AddressSanitizerRuntime();
-    
-    virtual lldb_private::ConstString
-    GetPluginName() { return GetPluginNameStatic(); }
-    
     virtual lldb::InstrumentationRuntimeType
     GetType() { return GetTypeStatic(); }
     
-    virtual uint32_t
-    GetPluginVersion() { return 1; }
+    uint32_t
+    GetPluginVersion() override
+    {
+        return 1;
+    }
     
-    virtual void
-    ModulesDidLoad(lldb_private::ModuleList &module_list);
+    void
+    ModulesDidLoad(lldb_private::ModuleList &module_list) override;
     
-    virtual bool
-    IsActive();
+    bool
+    IsActive() override;
     
 private:
+    AddressSanitizerRuntime(const lldb::ProcessSP &process_sp);
 
     lldb::ProcessSP
     GetProcessSP ()

         return m_process_wp.lock();
     }
 
-    AddressSanitizerRuntime(const lldb::ProcessSP &process_sp);
-    
     void
     Activate();
     

     lldb::ModuleSP m_runtime_module;
     lldb::ProcessWP m_process_wp;
     lldb::user_id_t m_breakpoint_id;
-
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_InstrumentationRuntime_h_
+#endif // liblldb_AddressSanitizerRuntime_h_