[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/Disassembler/llvm/DisassemblerLLVMC.h

 //===-- DisassemblerLLVMC.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_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 MCContext;
     class MCInst;
     class MCInstrInfo;
     class MCRegisterInfo;
     class MCDisassembler;
     class MCInstPrinter;
     class MCAsmInfo;
     class MCSubtargetInfo;
-}
-
-#include "lldb/Core/Address.h"
-#include "lldb/Core/Disassembler.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Host/Mutex.h"
+} // namespace llvm
 
 class InstructionLLVMC;
 
 class DisassemblerLLVMC : public lldb_private::Disassembler
 {
     // Since we need to make two actual MC Disassemblers for ARM (ARM & THUMB), and there's a bit of goo to set up and own
     // in the MC disassembler world, I added this class to manage the actual disassemblers.
     class LLVMCDisassembler
     {
     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);
         void     SetStyle (bool use_hex_immed, HexImmediateStyle hex_style);
         bool     CanBranch (llvm::MCInst &mc_inst);
         bool     HasDelaySlot (llvm::MCInst &mc_inst);
         bool     IsValid()
         {
             return m_is_valid;
         }
 
     private:
         bool                                     m_is_valid;
         std::unique_ptr<llvm::MCContext>         m_context_ap;
         std::unique_ptr<llvm::MCAsmInfo>         m_asm_info_ap;
         std::unique_ptr<llvm::MCSubtargetInfo>   m_subtarget_info_ap;
         std::unique_ptr<llvm::MCInstrInfo>       m_instr_info_ap;
         std::unique_ptr<llvm::MCRegisterInfo>    m_reg_info_ap;
         std::unique_ptr<llvm::MCInstPrinter>     m_instr_printer_ap;
         std::unique_ptr<llvm::MCDisassembler>    m_disasm_ap;
     };
 
 public:
+    DisassemblerLLVMC(const lldb_private::ArchSpec &arch, const char *flavor /* = NULL */);
+
+    ~DisassemblerLLVMC() override = default;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static lldb_private::Disassembler *
     CreateInstance(const lldb_private::ArchSpec &arch, const char *flavor);
 
-    DisassemblerLLVMC(const lldb_private::ArchSpec &arch, const char *flavor /* = NULL */);
-
-    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);
+    size_t
+    DecodeInstructions(const lldb_private::Address &base_addr,
+                       bool data_from_file) override;
 
     //------------------------------------------------------------------
     // 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()
     {
         return (m_disasm_ap.get() != NULL && m_disasm_ap->IsValid());
     }
 
     int OpInfo(uint64_t PC,
protected:
     InstructionLLVMC *m_inst;
     lldb_private::Mutex m_mutex;
     bool m_data_from_file;
 
     std::unique_ptr<LLVMCDisassembler> m_disasm_ap;
     std::unique_ptr<LLVMCDisassembler> m_alternate_disasm_ap;
 };
 
-#endif  // liblldb_DisassemblerLLVM_h_
+#endif // liblldb_DisassemblerLLVM_h_

lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

 //===-- DisassemblerLLVMC.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#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/MC/MCDisassembler.h"
 #include "llvm/MC/MCExternalSymbolizer.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCRelocationInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TargetRegistry.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"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
InstructionLLVMC (DisassemblerLLVMC &disasm,
         m_disasm_sp (disasm.shared_from_this()),
         m_does_branch (eLazyBoolCalculate),
         m_has_delay_slot (eLazyBoolCalculate),
         m_is_valid (false),
         m_using_file_addr (false)
     {
     }
 
-    virtual
-    ~InstructionLLVMC ()
-    {
-    }
+    ~InstructionLLVMC() override = default;
 
-    virtual bool
-    DoesBranch ()
+    bool
+    DoesBranch() override
     {
         if (m_does_branch == eLazyBoolCalculate)
         {
             GetDisassemblerLLVMC().Lock(this, NULL);
             DataExtractor data;
             if (m_opcode.GetData(data))
             {
                 bool is_alternate_isa;
DoesBranch() override
                         m_does_branch = eLazyBoolNo;
                 }
             }
             GetDisassemblerLLVMC().Unlock();
         }
         return m_does_branch == eLazyBoolYes;
     }
 
-    virtual bool
-    HasDelaySlot ()
+    bool
+    HasDelaySlot() override
     {
         if (m_has_delay_slot == eLazyBoolCalculate)
         {
             GetDisassemblerLLVMC().Lock(this, NULL);
             DataExtractor data;
             if (m_opcode.GetData(data))
             {
                 bool is_alternate_isa;
GetDisasmToUse (bool &is_alternate_isa)
             {
                 is_alternate_isa = true;
                 return llvm_disasm.m_alternate_disasm_ap.get();
             }
         }
         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
         bool got_op = false;
         DisassemblerLLVMC &llvm_disasm = GetDisassemblerLLVMC();
         const ArchSpec &arch = llvm_disasm.GetArchitecture();
         const lldb::ByteOrder byte_order = data.GetByteOrder();
 
AppendComment (std::string &description)
             m_comment.swap (description);
         else
         {
             m_comment.append(", ");
             m_comment.append(description);
         }
     }
 
-    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 ();
 
         if (m_opcode.GetData(data))
         {
             char out_string[512];
 
protected:
 
     DisassemblerSP          m_disasm_sp; // for ownership
     LazyBool                m_does_branch;
     LazyBool                m_has_delay_slot;
     bool                    m_is_valid;
     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)
 {
     std::string Error;
     const llvm::Target *curr_target = llvm::TargetRegistry::lookupTarget(triple, Error);
     if (!curr_target)
     {
         m_is_valid = false;
if (m_disasm_ap.get() && m_context_ap.get())
             m_disasm_ap.reset();
             m_is_valid = false;
         }
     }
     else
         m_is_valid = false;
 }
 
-DisassemblerLLVMC::LLVMCDisassembler::~LLVMCDisassembler()
-{
-}
-
 uint64_t
 DisassemblerLLVMC::LLVMCDisassembler::GetMCInst (const uint8_t *opcode_data,
                                                  size_t opcode_data_len,
                                                  lldb::addr_t pc,
                                                  llvm::MCInst &mc_inst)
 {
     llvm::ArrayRef<uint8_t> data(opcode_data, opcode_data_len);
     llvm::MCDisassembler::DecodeStatus status;
if (triple.getArch() == llvm::Triple::x86 || triple.getArch() == llvm::Triple::x86_64)
             return true;
         else
             return false;
     }
     else
         return false;
 }
 
-
 Disassembler *
 DisassemblerLLVMC::CreateInstance (const ArchSpec &arch, const char *flavor)
 {
     if (arch.GetTriple().getArch() != llvm::Triple::UnknownArch)
     {
         std::unique_ptr<DisassemblerLLVMC> disasm_ap (new DisassemblerLLVMC(arch, flavor));
 
         if (disasm_ap.get() && disasm_ap->IsValid())
else if (llvm_arch == llvm::Triple::mips
         if (!m_alternate_disasm_ap->IsValid())
         {
             m_disasm_ap.reset();
             m_alternate_disasm_ap.reset();
         }
     }
 }
 
-DisassemblerLLVMC::~DisassemblerLLVMC()
-{
-}
-
 size_t
 DisassemblerLLVMC::DecodeInstructions (const Address &base_addr,
                                        const DataExtractor& data,
                                        lldb::offset_t data_offset,
                                        size_t num_instructions,
                                        bool append,
                                        bool data_from_file)
 {

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

 //===-- DynamicLoaderDarwinKernel.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_DynamicLoaderDarwinKernel_h_
 #define liblldb_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"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 class DynamicLoaderDarwinKernel : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderDarwinKernel(lldb_private::Process *process, lldb::addr_t kernel_addr);
+
+    ~DynamicLoaderDarwinKernel() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     static lldb_private::DynamicLoader *
     CreateInstance (lldb_private::Process *process, bool force);
 
     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
     PrivateInitialize (lldb_private::Process *process);
 
     void
     PrivateProcessStateChanged (lldb_private::Process *process,
                                 lldb::StateType state);
private:
         std::string              m_name;
         lldb::ModuleSP           m_module_sp;
         lldb::ModuleSP           m_memory_module_sp;
         uint32_t                 m_load_process_stop_id; // the stop-id when this module was added to the Target
         lldb_private::UUID       m_uuid;                 // UUID for this dylib if it has one, else all zeros
         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
     {
         uint32_t version;
         uint32_t entry_size;
         uint32_t entry_count;
         lldb::addr_t image_infos_addr;
protected:
     KextImageInfo::collection      m_known_kexts;
     mutable lldb_private::Mutex    m_mutex;
     lldb::user_id_t                m_break_id;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (DynamicLoaderDarwinKernel);
 };
 
-#endif  // liblldb_DynamicLoaderDarwinKernel_h_
+#endif // liblldb_DynamicLoaderDarwinKernel_h_

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

 //===-- DynamicLoaderHexagon.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_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"
 
 #include "HexagonDYLDRendezvous.h"
 
 class DynamicLoaderHexagonDYLD : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderHexagonDYLD(lldb_private::Process *process);
+
+    ~DynamicLoaderHexagonDYLD() override;
 
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     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:
     /// Runtime linker rendezvous structure.
     HexagonDYLDRendezvous m_rendezvous;
 
     /// Virtual load address of the inferior process.
     lldb::addr_t m_load_offset;
protected:
     lldb::ModuleSP
     GetTargetExecutable();
 
     /// return the address of the Rendezvous breakpoint
     lldb::addr_t
     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_

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

 //===-- DynamicLoaderMacOSXDYLD.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_DynamicLoaderMacOSXDYLD_h_
 #define liblldb_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 void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     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
     PrivateInitialize (lldb_private::Process *process);
 
     void
     PrivateProcessStateChanged (lldb_private::Process *process,
                                 lldb::StateType state);
+
     bool
     LocateDYLD ();
 
     bool
     DidSetNotificationBreakpoint () const;
 
     void
     Clear (bool clear_process);
protected:
 
     static lldb::ByteOrder
     GetByteOrderFromMagic (uint32_t magic);
 
     bool
     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),
             vmsize(0),
             fileoff(0),
             filesize(0),
             maxprot(0),
             initprot(0),
protected:
     mutable lldb_private::Mutex m_mutex;
     lldb_private::Process::Notifications m_notification_callbacks;
     bool m_process_image_addr_is_all_images_infos;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (DynamicLoaderMacOSXDYLD);
 };
 
-#endif  // liblldb_DynamicLoaderMacOSXDYLD_h_
+#endif // liblldb_DynamicLoaderMacOSXDYLD_h_

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

-//===-- DynamicLoaderPOSIX.h ------------------------------------*- C++ -*-===//
+//===-- DynamicLoaderPOSIXDYLD.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_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"
 
 #include "DYLDRendezvous.h"
 
 class AuxVector;
 
 class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderPOSIXDYLD(lldb_private::Process *process);
+
+    ~DynamicLoaderPOSIXDYLD() override;
 
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     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:
     /// Runtime linker rendezvous structure.
     DYLDRendezvous m_rendezvous;
 
     /// Virtual load address of the inferior process.
     lldb::addr_t m_load_offset;
protected:
     /// Loads Module from inferior process.
     void
     ResolveExecutableModule(lldb::ModuleSP &module_sp);
 
 private:
     DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
 };
 
-#endif  // liblldb_DynamicLoaderPOSIXDYLD_H_
+#endif // liblldb_DynamicLoaderPOSIXDYLD_h_

lldb/trunk/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h

 //===-- DynamicLoaderStatic.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_DynamicLoaderStatic_h_
 #define liblldb_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"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 class DynamicLoaderStatic : public lldb_private::DynamicLoader
 {
 public:
+    DynamicLoaderStatic(lldb_private::Process *process);
+
+    ~DynamicLoaderStatic() override;
+
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
 
     static void
     Terminate();
 
     static lldb_private::ConstString
     GetPluginNameStatic();
 
     static const char *
     GetPluginDescriptionStatic();
 
     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
     LoadAllImagesAtFileAddresses ();
 
     DISALLOW_COPY_AND_ASSIGN (DynamicLoaderStatic);
 };
 
-#endif  // liblldb_DynamicLoaderStatic_h_
+#endif // liblldb_DynamicLoaderStatic_h_

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

-//===-- DynamicLoaderWindowsDYLDh ----------------------------------*- C++ -*-===//
+//===-- DynamicLoaderWindowsDYLD.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_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"
 
 namespace lldb_private
 {
 
 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;
     void DidLaunch() override;
     Error CanLoadImage() override;
     lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop) override;
 
     ConstString GetPluginName() override;
     uint32_t GetPluginVersion() override;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_h_

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 //===-- ClangExpressionParser.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#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 "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/CodeGen/CodeGenAction.h"
 #include "clang/CodeGen/ModuleBuilder.h"

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/DynamicLibrary.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;
 
 //===----------------------------------------------------------------------===//
 // Utility Methods for Clang
 //===----------------------------------------------------------------------===//
 

 }
 
 class ClangExpressionParser::LLDBPreprocessorCallbacks : public PPCallbacks
 {
     ClangModulesDeclVendor     &m_decl_vendor;
     ClangPersistentVariables   &m_persistent_vars;
     StreamString                m_error_stream;
     bool                        m_has_errors = false;
+
 public:
     LLDBPreprocessorCallbacks(ClangModulesDeclVendor &decl_vendor,
                               ClangPersistentVariables &persistent_vars) :
         m_decl_vendor(decl_vendor),
         m_persistent_vars(persistent_vars)
     {
     }
     
-    virtual void moduleImport(SourceLocation import_location,
-                              clang::ModuleIdPath path,
-                              const clang::Module * /*null*/)
+    void
+    moduleImport(SourceLocation import_location,
+                 const clang::Module * /*null*/) override
     {
         std::vector<ConstString> string_path;
         
         for (const std::pair<IdentifierInfo *, SourceLocation> &component : path)
         {
             string_path.push_back(ConstString(component.first->getName()));
         }
      

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h

-//===-- ClangFunctionCaller.h -----------------------------------------*- C++ -*-===//
+//===-- ClangFunctionCaller.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_ClangFunctionCaller_h_
 #define liblldb_ClangFunctionCaller_h_
 
 // C Includes
 // C++ Includes
-#include <vector>
-#include <list>
 // Other libraries and framework includes
 // Project includes
 #include "ClangExpressionHelper.h"
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Value.h"
class ClangFunctionCaller : public FunctionCaller
     class ClangFunctionCallerHelper : public ClangExpressionHelper
     {
     public:
         ClangFunctionCallerHelper (ClangFunctionCaller &owner) :
             m_owner(owner)
         {
         }
         
-        ~ClangFunctionCallerHelper() {}
+        ~ClangFunctionCallerHelper() override = default;
         
         //------------------------------------------------------------------
         /// Return the object that the parser should use when resolving external
         /// values.  May be NULL if everything should be self-contained.
         //------------------------------------------------------------------
         ClangExpressionDeclMap *
         DeclMap() override
         {
             return NULL;
         }
         
         //------------------------------------------------------------------
         /// Return the object that the parser should allow to access ASTs.
         /// May be NULL if the ASTs do not need to be transformed.
         ///
         /// @param[in] passthrough
         ///     The ASTConsumer that the returned transformer should send
         ///     the ASTs to after transformation.
         //------------------------------------------------------------------
         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.
     };
 
 public:
     //------------------------------------------------------------------
     /// Constructor
public:
     ///     be overridden using WriteFunctionArguments().
     //------------------------------------------------------------------
     ClangFunctionCaller (ExecutionContextScope &exe_scope,
                          const CompilerType &return_type,
                          const Address& function_address,
                          const ValueList &arg_value_list,
                          const char *name);
     
-    //------------------------------------------------------------------
-    /// Destructor
-    //------------------------------------------------------------------
     ~ClangFunctionCaller() override;
 
     //------------------------------------------------------------------
     /// Compile the wrapper function
     ///
     /// @param[in] errors
     ///     The stream to print parser errors to.
     ///
     /// @return
     ///     The number of errors.
     //------------------------------------------------------------------
     unsigned
     CompileFunction (Stream &errors) override;
     
     ExpressionTypeSystemHelper *
     GetTypeSystemHelper () 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_

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 //===-- ClangModulesDeclVendor.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#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/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.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 {
     // Any Clang compiler requires a consumer for diagnostics.  This one stores them as strings
     // so we can provide them to the user in case a module failed to load.
     class StoringDiagnosticConsumer : public clang::DiagnosticConsumer
     {
     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;
         Log * m_log;
     };
     
     // The private implementation of our ClangModulesDeclVendor.  Contains all the Clang state required
     // to load modules.
     class ClangModulesDeclVendorImpl : public ClangModulesDeclVendor
     {
     public:
         ClangModulesDeclVendorImpl(llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> &diagnostics_engine,
                                    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;
-        
-        virtual uint32_t
-        FindDecls (const ConstString &name,
-                   bool append,
-                   uint32_t max_matches,
-                   std::vector <clang::NamedDecl*> &decls) override;
+        uint32_t
+        FindDecls(const ConstString &name,
         
-        virtual void
+        void
         ForEachMacro(const ModuleVector &modules,
                      std::function<bool (const std::string &)> handler) override;
         
-        ~ClangModulesDeclVendorImpl();
-        
     private:
         void
         ReportModuleExportsHelper (std::set<ClangModulesDeclVendor::ModuleID> &exports,
                                    clang::Module *module);
 
         void
         ReportModuleExports (ModuleVector &exports,
                              clang::Module *module);
private:
         size_t                                              m_source_location_index = 0; // used to give name components fake SourceLocations
 
         typedef std::vector<ConstString>                    ImportedModule;
         typedef std::map<ImportedModule, clang::Module *>   ImportedModuleMap;
         typedef std::set<ModuleID>                          ImportedModuleSet;
         ImportedModuleMap                                   m_imported_modules;
         ImportedModuleSet                                   m_user_imported_modules;
     };
-}
+} // anonymous namespace
 
 StoringDiagnosticConsumer::StoringDiagnosticConsumer ()
 {
     m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
 }
 
 void
 StoringDiagnosticConsumer::HandleDiagnostic (clang::DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info)
GetResourceDir ()
     
     std::call_once(g_once_flag, [](){
         HostInfo::GetLLDBPath (lldb::ePathTypeClangDir, g_cached_resource_dir);
     });
     
     return g_cached_resource_dir;
 }
 
-
 ClangModulesDeclVendor::ClangModulesDeclVendor()
 {
 }
 
 ClangModulesDeclVendor::~ClangModulesDeclVendor()
 {
 }
 
if (requested_module != nullptr)
         m_enabled = true;
         
         return true;
     }
     
     return false;
 }
 
-
 bool
 ClangModulesDeclVendor::LanguageSupportsClangModules (lldb::LanguageType language)
 {
     switch (language)
     {
     default:
         return false;
     // C++ and friends to be added
for (clang::Preprocessor::macro_iterator mi = m_compiler_instance->getPreprocessor().macro_begin(),
                 {
                     return;
                 }
             }
         }
     }
 }
 
-ClangModulesDeclVendorImpl::~ClangModulesDeclVendorImpl()
-{
-}
-
 clang::ModuleLoadResult
 ClangModulesDeclVendorImpl::DoGetModule(clang::ModuleIdPath path,
                                         bool make_visible)
 {
     clang::Module::NameVisibilityKind visibility = make_visible ? clang::Module::AllVisible : clang::Module::Hidden;
     
     const bool is_inclusion_directive = false;
     

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h

 //===-- ClangPersistentVariables.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_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 ClangPersistentVariables.h "lldb/Expression/ClangPersistentVariables.h"
 /// @brief Manages persistent values that need to be preserved between expression invocations.
 ///
 /// A list of variables that can be accessed and updated by any expression.  See
 /// ClangPersistentVariable for more discussion.  Also provides an increasing,
 /// 0-based counter for naming result variables.
 //----------------------------------------------------------------------
 class ClangPersistentVariables : public PersistentExpressionState
 {
 public:
-    
-    //----------------------------------------------------------------------
-    /// Constructor
-    //----------------------------------------------------------------------
-    ClangPersistentVariables ();
-    
-    ~ClangPersistentVariables () { }
-    
+    ClangPersistentVariables();
+    ~ClangPersistentVariables() override = default;
     //------------------------------------------------------------------
     // llvm casting support
     //------------------------------------------------------------------
     static bool classof(const PersistentExpressionState *pv)
     {
         return pv->getKind() == PersistentExpressionState::eKindClang;
     }
 
private:
     
     typedef llvm::DenseMap<const char *, clang::TypeDecl *> PersistentTypeMap;
     PersistentTypeMap                                       m_persistent_types;             ///< The persistent types declared by the user.
     
     ClangModulesDeclVendor::ModuleVector                    m_hand_loaded_clang_modules;    ///< These are Clang modules we hand-loaded; these are the highest-
                                                                                             ///< priority source for macros.
 };
 
-}
+} // namespace lldb_private
 
-#endif
+#endif // liblldb_ClangPersistentVariables_h_

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

 //===-- ClangUserExpression.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_ClangUserExpression_h_
 #define liblldb_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"
 #include "ClangExpressionHelper.h"
 #include "ClangExpressionVariable.h"
 #include "IRForTarget.h"
 
 #include "lldb/lldb-forward.h"

 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  ClangUserExpression encapsulates
 /// the objects needed to parse and interpret or JIT an expression.  It
 /// uses the Clang parser to produce LLVM IR from the expression.
 //----------------------------------------------------------------------
 class ClangUserExpression : public UserExpression
 {
 public:
-
     enum { kDefaultTimeout = 500000u };
 
-
     class ClangUserExpressionHelper : public ClangExpressionHelper
     {
     public:
         ClangUserExpressionHelper (Target &target) :
             m_target(target)
         {
         }
         
-        ~ClangUserExpressionHelper() {}
+        ~ClangUserExpressionHelper() override = default;
         
         //------------------------------------------------------------------
         /// Return the object that the parser should use when resolving external
         /// values.  May be NULL if everything should be self-contained.
         //------------------------------------------------------------------
         ClangExpressionDeclMap *
         DeclMap() override
         {
public:
         /// May be NULL if the ASTs do not need to be transformed.
         ///
         /// @param[in] passthrough
         ///     The ASTConsumer that the returned transformer should send
         ///     the ASTs to after transformation.
         //------------------------------------------------------------------
         clang::ASTConsumer *
         ASTTransformer(clang::ASTConsumer *passthrough) override;
+
     private:
         Target                                  &m_target;
         std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up;
         std::unique_ptr<ASTStructExtractor> m_struct_extractor_up;         ///< The class that generates the argument struct layout.
         std::unique_ptr<ASTResultSynthesizer> m_result_synthesizer_up;
     };
 
     //------------------------------------------------------------------
public:
     ///     result.
     //------------------------------------------------------------------
     ClangUserExpression (ExecutionContextScope &exe_scope,
                          const char *expr,
                          const char *expr_prefix,
                          lldb::LanguageType language,
                          ResultType desired_type);
 
-    //------------------------------------------------------------------
-    /// Destructor
-    //------------------------------------------------------------------
     ~ClangUserExpression() override;
 
     //------------------------------------------------------------------
     /// Parse the expression
     ///
     /// @param[in] error_stream
     ///     A stream to print parse errors and warnings to.
     ///
private:
     {
     public:
         ResultDelegate();
         ConstString GetName() override;
         void DidDematerialize(lldb::ExpressionVariableSP &variable) override;
         
         void RegisterPersistentState(PersistentExpressionState *persistent_state);
         lldb::ExpressionVariableSP &GetVariable();
+
     private:
         PersistentExpressionState *m_persistent_state;
         lldb::ExpressionVariableSP m_variable;
     };
     
     ResultDelegate                                          m_result_delegate;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangUserExpression_h_

lldb/trunk/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.h

-//===-- EmulateInstructionARM64.h ------------------------------------*- C++ -*-===//
+//===-- EmulateInstructionARM64.h -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 #include "Plugins/Process/Utility/ARMDefines.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 ();
     
     static void
     Terminate ();
 
     static lldb_private::ConstString
     GetPluginNameStatic ();
SupportsEmulatingInstructionsOfTypeStatic (lldb_private::InstructionType inst_type)
 
             case lldb_private::eInstructionTypePCModifying:
             case lldb_private::eInstructionTypeAll:
                 return false;
         }
         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);
-    
-    EmulateInstructionARM64 (const lldb_private::ArchSpec &arch) :
-        EmulateInstruction (arch),
-        m_opcode_pstate (),
-        m_emulated_pstate (),
-        m_ignore_conditions (false)
-    {
-    }
+    SetTargetTriple(const lldb_private::ArchSpec &arch) override;
     
-    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);
-
-    virtual bool
-    CreateFunctionEntryUnwind (lldb_private::UnwindPlan &unwind_plan);
+    bool
+    GetRegisterInfo(lldb::RegisterKind reg_kind,
+                    uint32_t reg_num,
+                    lldb_private::RegisterInfo &reg_info) override;
 
-    
+    bool
+    CreateFunctionEntryUnwind(lldb_private::UnwindPlan &unwind_plan) override;
     typedef enum 
     {
         AddrMode_OFF, 
         AddrMode_PRE, 
         AddrMode_POST
     } AddrMode;
     
     typedef enum 
typedef enum
         RevOp_REV64
     } RevOp;
     
     typedef enum 
     {
         BitwiseOp_NOT, 
         BitwiseOp_RBIT
     } BitwiseOp;
-    
-
     typedef enum
     {
         EL0 = 0,
         EL1 = 1, 
         EL2 = 2,
         EL3 = 3
     } ExceptionLevel;
     
typedef struct
             E:1,   // AArch32 only – CSPR.E bit
             M:5,   // AArch32 only – mode encodings
             RW:1,  // Current register width – 0 is AArch64, 1 is AArch32
             EL:2,  // Current exception level (see ExceptionLevel enum)
             SP:1;  // AArch64 only - Stack Pointer selection (see StackPointerSelection enum)
     } ProcState;
 
 protected:
-
     typedef struct
     {
         uint32_t mask;
         uint32_t value;
         uint32_t vfp_variants;
         bool (EmulateInstructionARM64::*callback) (const uint32_t opcode);
         const char *name;
     }  Opcode;
protected:
     bool
     EmulateTBZ (const uint32_t opcode);
 
     ProcState m_opcode_pstate;
     ProcState m_emulated_pstate; // This can get updated by the opcode.
     bool m_ignore_conditions;
 };
 
-#endif  // EmulateInstructionARM64_h_
+#endif // EmulateInstructionARM64_h_

lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h

-//===-- EmulateInstructionMIPS64.h ------------------------------------*- C++ -*-===//
+//===-- EmulateInstructionMIPS64.h ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #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 MCSubtargetInfo;
     class MCRegisterInfo;
     class MCAsmInfo;
     class MCContext;
     class MCInstrInfo;
     class MCInst;
-}
-
-#include "lldb/Core/EmulateInstruction.h"
-#include "lldb/Core/Error.h"
-#include "lldb/Interpreter/OptionValue.h"
+} // namespace llvm
 
 class EmulateInstructionMIPS64 : public lldb_private::EmulateInstruction
 {
 public: 
+    EmulateInstructionMIPS64(const lldb_private::ArchSpec &arch);
+
     static void
     Initialize ();
 
     static void
     Terminate ();
 
     static lldb_private::ConstString
     GetPluginNameStatic ();
SupportsEmulatingInstructionsOfTypeStatic (lldb_private::InstructionType inst_type)
                 return true;
 
             case lldb_private::eInstructionTypeAll:
                 return false;
         }
         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);
-
-    virtual bool
-    CreateFunctionEntryUnwind (lldb_private::UnwindPlan &unwind_plan);
+    bool
+    GetRegisterInfo(lldb::RegisterKind reg_kind,
+                    uint32_t reg_num,
+                    lldb_private::RegisterInfo &reg_info) override;
 
+    bool
+    CreateFunctionEntryUnwind(lldb_private::UnwindPlan &unwind_plan) override;
 
 protected:
-
     typedef struct
     {
         const char *op_name;
         bool (EmulateInstructionMIPS64::*callback) (llvm::MCInst& insn);
         const char *insn_name;
     }  MipsOpcode;
     
     static MipsOpcode*
private:
     std::unique_ptr<llvm::MCDisassembler>   m_disasm;
     std::unique_ptr<llvm::MCSubtargetInfo>  m_subtype_info;
     std::unique_ptr<llvm::MCRegisterInfo>   m_reg_info;
     std::unique_ptr<llvm::MCAsmInfo>        m_asm_info;
     std::unique_ptr<llvm::MCContext>        m_context;
     std::unique_ptr<llvm::MCInstrInfo>      m_insn_info;
 };
 
-#endif  // EmulateInstructionMIPS64_h_
+#endif // EmulateInstructionMIPS64_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h

 //===-- AddressSanitizerRuntime.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_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"
 #include "lldb/Target/Process.h"
 #include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
     
 class AddressSanitizerRuntime : public lldb_private::InstrumentationRuntime
 {
 public:
-    
+    ~AddressSanitizerRuntime() override;
     static lldb::InstrumentationRuntimeSP
     CreateInstance (const lldb::ProcessSP &process_sp);
     
     static void
     Initialize();
     
     static void
     Terminate();
     
     static lldb_private::ConstString
     GetPluginNameStatic();
     
     static lldb::InstrumentationRuntimeType
     GetTypeStatic();
-    
-    virtual
-    ~AddressSanitizerRuntime();
-    
-    virtual lldb_private::ConstString
-    GetPluginName() { return GetPluginNameStatic(); }
+    lldb_private::ConstString
+    GetPluginName() override
+    { 
+        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();
     
     void
     Deactivate();
     
     static bool
     NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
     
     StructuredData::ObjectSP
     RetrieveReportData();
     
     std::string
     FormatDescription(StructuredData::ObjectSP report);
     
     bool m_is_active;
     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_