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

[Eugene.Zelenko]

Summary

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

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h

-//===-- ItaniumABILanguageRuntime.h ----------------------------------------*- C++ -*-===//
+//===-- ItaniumABILanguageRuntime.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_ItaniumABILanguageRuntime_h_
 #define liblldb_ItaniumABILanguageRuntime_h_
 
 // C Includes
 // C++ Includes
+#include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Core/Value.h"
 
-#include <map>
-#include <vector>
-
 namespace lldb_private {
     
     class ItaniumABILanguageRuntime :
     public lldb_private::CPPLanguageRuntime
     {
     public:
-        ~ItaniumABILanguageRuntime() { }
-        
-        virtual bool
-        IsVTableName (const char *name);
-        
-        virtual bool
-        GetDynamicTypeAndAddress (ValueObject &in_value, 
-                                  lldb::DynamicValueType use_dynamic, 
-                                  TypeAndOrName &class_type_or_name, 
-                                  Address &address,
-                                  Value::ValueType &value_type);
-        
-        virtual TypeAndOrName
-        FixUpDynamicType (const TypeAndOrName& type_and_or_name,
-                          ValueObject& static_value);
-        
-        virtual bool
-        CouldHaveDynamicValue (ValueObject &in_value);
+        ~ItaniumABILanguageRuntime() override = default;
         
         //------------------------------------------------------------------
         // Static Functions
         //------------------------------------------------------------------
         static void
         Initialize();
         
         static void
         Terminate();
         
         static lldb_private::LanguageRuntime *
         CreateInstance (Process *process, lldb::LanguageType language);
         
         static lldb_private::ConstString
         GetPluginNameStatic();
 
-        //------------------------------------------------------------------
-        // PluginInterface protocol
-        //------------------------------------------------------------------
-        virtual lldb_private::ConstString
-        GetPluginName();
+        bool
+        IsVTableName(const char *name) override;
         
-        virtual uint32_t
-        GetPluginVersion();
+        bool
+        GetDynamicTypeAndAddress(ValueObject &in_value,
+                                 lldb::DynamicValueType use_dynamic,
+                                 TypeAndOrName &class_type_or_name,
+                                 Address &address,
+                                 Value::ValueType &value_type) override;
         
-        virtual void
-        SetExceptionBreakpoints ();
+        TypeAndOrName
+        FixUpDynamicType(const TypeAndOrName& type_and_or_name,
+                         ValueObject& static_value) override;
         
-        virtual void
-        ClearExceptionBreakpoints ();
+        bool
+        CouldHaveDynamicValue(ValueObject &in_value) override;
         
-        virtual bool
-        ExceptionBreakpointsAreSet ();
+        void
+        SetExceptionBreakpoints() override;
         
-        virtual bool
-        ExceptionBreakpointsExplainStop (lldb::StopInfoSP stop_reason);
+        void
+        ClearExceptionBreakpoints() override;
         
-        virtual lldb::BreakpointResolverSP
-        CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp);
+        bool
+        ExceptionBreakpointsAreSet() override;
         
-        virtual lldb::SearchFilterSP
-        CreateExceptionSearchFilter ();
+        bool
+        ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override;
 
-        virtual size_t
-        GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates);
+        lldb::BreakpointResolverSP
+        CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
         
-    protected:
+        lldb::SearchFilterSP
+        CreateExceptionSearchFilter() override;
 
+        size_t
+        GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) override;
+
+        //------------------------------------------------------------------
+        // PluginInterface protocol
+        //------------------------------------------------------------------
+        lldb_private::ConstString
+        GetPluginName() override;
+        
+        uint32_t
+        GetPluginVersion() override;
+
+    protected:
         lldb::BreakpointResolverSP
         CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp, bool for_expressions);
 
         lldb::BreakpointSP
         CreateExceptionBreakpoint(bool catch_bp,
                                   bool throw_bp,
                                   bool for_expressions,
                                   bool is_internal);
         
     private:
         ItaniumABILanguageRuntime(Process *process) : lldb_private::CPPLanguageRuntime(process) { } // Call CreateInstance instead.
         
         lldb::BreakpointSP                              m_cxx_exception_bp_sp;
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_ItaniumABILanguageRuntime_h_
+#endif // liblldb_ItaniumABILanguageRuntime_h_

lldb/trunk/source/Plugins/LanguageRuntime/Go/GoLanguageRuntime.h

-//===-- GoLanguageRuntime.h ----------------------------------------*- C++ -*-===//
+//===-- GoLanguageRuntime.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 #include "lldb/Core/Value.h"
 
 namespace lldb_private {
     
     class GoLanguageRuntime :
     public lldb_private::LanguageRuntime
     {
     public:
-        ~GoLanguageRuntime() { }
+        ~GoLanguageRuntime() override = default;
+
+        //------------------------------------------------------------------
+        // Static Functions
+        //------------------------------------------------------------------
+        static void
+        Initialize();
+        
+        static void
+        Terminate();
+        
+        static lldb_private::LanguageRuntime *
+        CreateInstance(Process *process, lldb::LanguageType language);
+        
+        static lldb_private::ConstString
+        GetPluginNameStatic();
 
         lldb::LanguageType
         GetLanguageType() const override
         {
             return lldb::eLanguageTypeGo;
         }
 
         bool
public:
         CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override
         {
             return lldb::BreakpointResolverSP();
         }
 
         TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value) override;
 
         //------------------------------------------------------------------
-        // Static Functions
-        //------------------------------------------------------------------
-        static void
-        Initialize();
-        
-        static void
-        Terminate();
-        
-        static lldb_private::LanguageRuntime *
-        CreateInstance (Process *process, lldb::LanguageType language);
-        
-        static lldb_private::ConstString
-        GetPluginNameStatic();
-        
-        //------------------------------------------------------------------
         // PluginInterface protocol
         //------------------------------------------------------------------
         lldb_private::ConstString
         GetPluginName() override;
         
         uint32_t
         GetPluginVersion() override;
         
     private:
         GoLanguageRuntime(Process *process) : lldb_private::LanguageRuntime(process) { } // Call CreateInstance instead.
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_GoLanguageRuntime_h_
+#endif // liblldb_GoLanguageRuntime_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h

-//===-- AppleObjCClassDescriptorV2.h --------------------------------*- C++ -*-===//
+//===-- AppleObjCClassDescriptorV2.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_AppleObjCClassDescriptorV2_h_
 #define liblldb_AppleObjCClassDescriptorV2_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "AppleObjCRuntimeV2.h"
 
 namespace lldb_private {
 
 class ClassDescriptorV2 : public ObjCLanguageRuntime::ClassDescriptor
 {
 public:
     friend class lldb_private::AppleObjCRuntimeV2;
     
-private:
-    // The constructor should only be invoked by the runtime as it builds its caches
-    // or populates them.  A ClassDescriptorV2 should only ever exist in a cache.
-    ClassDescriptorV2 (AppleObjCRuntimeV2 &runtime, ObjCLanguageRuntime::ObjCISA isa, const char *name) :
-        m_runtime (runtime),
-        m_objc_class_ptr (isa),
-        m_name (name),
-        m_ivars_storage()
-    {
-    }
-    
-public:
-    virtual ConstString
-    GetClassName ();
+    ~ClassDescriptorV2() override = default;
+    ConstString
+    GetClassName() override;
     
-    virtual ObjCLanguageRuntime::ClassDescriptorSP
-    GetSuperclass ();
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetSuperclass() override;
     
-    virtual ObjCLanguageRuntime::ClassDescriptorSP
-    GetMetaclass () const;
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetMetaclass() const override;
     
-    virtual bool
-    IsValid ()
+    bool
+    IsValid() override
     {
         return true;    // any Objective-C v2 runtime class descriptor we vend is valid
     }
     
     // a custom descriptor is used for tagged pointers
-    virtual bool
-    GetTaggedPointerInfo (uint64_t* info_bits = NULL,
-                          uint64_t* value_bits = NULL,
-                          uint64_t* payload = NULL)
+    bool
+    GetTaggedPointerInfo(uint64_t* info_bits = nullptr,
+                         uint64_t* value_bits = nullptr,
+                         uint64_t* payload = nullptr) override
     {
         return false;
     }
     
-    virtual uint64_t
-    GetInstanceSize ();
+    uint64_t
+    GetInstanceSize() override;
     
-    virtual ObjCLanguageRuntime::ObjCISA
-    GetISA ()
+    ObjCLanguageRuntime::ObjCISA
+    GetISA() override
     {
         return m_objc_class_ptr;
     }
     
-    virtual bool
-    Describe (std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
-              std::function <bool (const char *, const char *)> const &instance_method_func,
-              std::function <bool (const char *, const char *)> const &class_method_func,
-              std::function <bool (const char *, const char *, lldb::addr_t, uint64_t)> const &ivar_func) const;
-    
-    virtual
-    ~ClassDescriptorV2 ()
-    {
-    }
-    
-    virtual size_t
-    GetNumIVars ()
+    bool
+    Describe(std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
+             std::function <bool (const char *, const char *,
+             lldb::addr_t, uint64_t)> const &ivar_func) const override;
+    size_t
+    GetNumIVars() override
     {
         GetIVarInformation();
         return m_ivars_storage.size();
     }
     
-    virtual iVarDescriptor
-    GetIVarAtIndex (size_t idx)
+    iVarDescriptor
+    GetIVarAtIndex(size_t idx) override
     {
         if (idx >= GetNumIVars())
             return iVarDescriptor();
         return m_ivars_storage[idx];
     }
     
 protected:
     void
public:
         fill (AppleObjCRuntimeV2& runtime, ClassDescriptorV2& descriptor);
         
     private:
         bool m_filled;
         std::vector<iVarDescriptor> m_ivars;
         Mutex m_mutex;
     };
     
+    // The constructor should only be invoked by the runtime as it builds its caches
+    // or populates them.  A ClassDescriptorV2 should only ever exist in a cache.
+    ClassDescriptorV2(AppleObjCRuntimeV2 &runtime, ObjCLanguageRuntime::ObjCISA isa, const char *name) :
+        m_runtime (runtime),
+        m_objc_class_ptr (isa),
+        m_name (name),
+        m_ivars_storage()
+    {
+    }
+    
     bool
     Read_objc_class (Process* process, std::unique_ptr<objc_class_t> &objc_class) const;
     
     bool
     Read_class_row (Process* process, const objc_class_t &objc_class, std::unique_ptr<class_ro_t> &class_ro, std::unique_ptr<class_rw_t> &class_rw) const;
     
     AppleObjCRuntimeV2 &m_runtime;          // The runtime, so we can read information lazily.
     lldb::addr_t        m_objc_class_ptr;   // The address of the objc_class_t.  (I.e., objects of this class type have this as their ISA)
ClassDescriptorV2Tagged (ObjCLanguageRuntime::ClassDescriptorSP actual_class_sp,
             return;
         }
         m_valid = true;
         m_payload = payload;
         m_info_bits = (m_payload & 0x0FULL);
         m_value_bits = (m_payload & ~0x0FULL) >> 4;
     }
     
-    virtual ConstString
-    GetClassName ()
+    ~ClassDescriptorV2Tagged() override = default;
+
+    ConstString
+    GetClassName() override
     {
         return m_name;
     }
     
-    virtual ObjCLanguageRuntime::ClassDescriptorSP
-    GetSuperclass ()
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetSuperclass() override
     {
         // tagged pointers can represent a class that has a superclass, but since that information is not
         // stored in the object itself, we would have to query the runtime to discover the hierarchy
         // for the time being, we skip this step in the interest of static discovery
         return ObjCLanguageRuntime::ClassDescriptorSP();
     }
     
-    virtual ObjCLanguageRuntime::ClassDescriptorSP
-    GetMetaclass () const
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetMetaclass() const override
     {
         return ObjCLanguageRuntime::ClassDescriptorSP();
     }
     
-    virtual bool
-    IsValid ()
+    bool
+    IsValid() override
     {
         return m_valid;
     }
     
-    virtual bool
-    IsKVO ()
+    bool
+    IsKVO() override
     {
         return false; // tagged pointers are not KVO'ed
     }
     
-    virtual bool
-    IsCFType ()
+    bool
+    IsCFType() override
     {
         return false; // tagged pointers are not CF objects
     }
     
-    virtual bool
-    GetTaggedPointerInfo (uint64_t* info_bits = NULL,
-                          uint64_t* value_bits = NULL,
-                          uint64_t* payload = NULL)
+    bool
+    GetTaggedPointerInfo(uint64_t* info_bits = nullptr,
+                         uint64_t* value_bits = nullptr,
+                         uint64_t* payload = nullptr) override
     {
         if (info_bits)
             *info_bits = GetInfoBits();
         if (value_bits)
             *value_bits = GetValueBits();
         if (payload)
             *payload = GetPayload();
         return true;
     }
     
-    virtual uint64_t
-    GetInstanceSize ()
+    uint64_t
+    GetInstanceSize() override
     {
         return (IsValid() ? m_pointer_size : 0);
     }
     
-    virtual ObjCLanguageRuntime::ObjCISA
-    GetISA ()
+    ObjCLanguageRuntime::ObjCISA
+    GetISA() override
     {
         return 0; // tagged pointers have no ISA
     }
     
     // these calls are not part of any formal tagged pointers specification
     virtual uint64_t
     GetValueBits ()
     {
         return (IsValid() ? m_value_bits : 0);
     }
     
     virtual uint64_t
     GetInfoBits ()
     {
         return (IsValid() ? m_info_bits : 0);
     }
     
     virtual uint64_t
     GetPayload ()
     {
         return (IsValid() ? m_payload : 0);
     }
-    
-    virtual
-    ~ClassDescriptorV2Tagged ()
-    {}
-    
 private:
     ConstString m_name;
     uint8_t m_pointer_size;
     bool m_valid;
     uint64_t m_info_bits;
     uint64_t m_value_bits;
     uint64_t m_payload;
-    
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_AppleObjCRuntime_h_
-
+#endif // liblldb_AppleObjCClassDescriptorV2_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h

 //===-- AppleObjCDeclVendor.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_AppleObjCDeclVendor_h_
 #define liblldb_AppleObjCDeclVendor_h_
 
 // C Includes
 // C++ Includes
-
-#include <map>
-
 // Other libraries and framework includes
-
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 
 namespace lldb_private {
 
 class AppleObjCExternalASTSource;
     
 class AppleObjCDeclVendor : public DeclVendor
 {
 public:
     AppleObjCDeclVendor(ObjCLanguageRuntime &runtime);
     
-    virtual uint32_t
-    FindDecls (const ConstString &name,
-               bool append,
-               uint32_t max_matches,
-               std::vector <clang::NamedDecl *> &decls);
+    uint32_t
+    FindDecls(const ConstString &name,
+              std::vector <clang::NamedDecl *> &decls) override;
         
     friend class AppleObjCExternalASTSource;
+
 private:
     clang::ObjCInterfaceDecl   *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa);
     bool                        FinishDecl(clang::ObjCInterfaceDecl *decl);
     
     ObjCLanguageRuntime        &m_runtime;
     ClangASTContext             m_ast_ctx;
     ObjCLanguageRuntime::EncodingToTypeSP m_type_realizer_sp;
     AppleObjCExternalASTSource *m_external_source;
     
     typedef llvm::DenseMap<ObjCLanguageRuntime::ObjCISA, clang::ObjCInterfaceDecl *> ISAToInterfaceMap;
 
     ISAToInterfaceMap           m_isa_to_interface;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_AppleObjCDeclVendor_h_
+#endif // liblldb_AppleObjCDeclVendor_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h

-//===-- AppleObjCRuntime.h ----------------------------------------*- C++ -*-===//
+//===-- AppleObjCRuntime.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_AppleObjCRuntime_h_
 #define liblldb_AppleObjCRuntime_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-
 #include "llvm/ADT/Optional.h"
 
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "AppleObjCTrampolineHandler.h"
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
 
 namespace lldb_private {
     
 class AppleObjCRuntime :
         public lldb_private::ObjCLanguageRuntime
 {
 public:
+    ~AppleObjCRuntime() override;
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    // Note there is no CreateInstance, Initialize & Terminate functions here, because
+    // you can't make an instance of this generic runtime.
+
     static bool classof(const ObjCLanguageRuntime* runtime)
     {
         switch (runtime->GetRuntimeVersion())
         {
             case ObjCRuntimeVersions::eAppleObjC_V1:
             case ObjCRuntimeVersions::eAppleObjC_V2:
                 return true;
             default:
                 return false;
         }
     }
     
-    virtual ~AppleObjCRuntime();
-    
     // These are generic runtime functions:
     bool
     GetObjectDescription (Stream &str, Value &value, ExecutionContextScope *exe_scope) override;
     
     bool
     GetObjectDescription (Stream &str, ValueObject &object) override;
     
     bool
public:
     lldb::ThreadPlanSP
     GetStepThroughTrampolinePlan (Thread &thread, bool stop_others) override;
     
     // Get the "libobjc.A.dylib" module from the current target if we can find
     // it, also cache it once it is found to ensure quick lookups.
     lldb::ModuleSP
     GetObjCModule ();
     
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    // Note there is no CreateInstance, Initialize & Terminate functions here, because
-    // you can't make an instance of this generic runtime.
-
-
     // Sync up with the target
 
     void
     ModulesDidLoad (const ModuleList &module_list) override;
 
-protected:
-    bool
-    CalculateHasNewLiteralsAndIndexing() override;
-    
-    static bool
-    AppleIsModuleObjCLibrary (const lldb::ModuleSP &module_sp);
-
-    static ObjCRuntimeVersions
-    GetObjCVersion (Process *process, lldb::ModuleSP &objc_module_sp);
-
-    void
-    ReadObjCLibraryIfNeeded (const ModuleList &module_list);
-
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-public:
     void
     SetExceptionBreakpoints() override;
 
     void
-    ClearExceptionBreakpoints () override;
+    ClearExceptionBreakpoints() override;
     
     bool
-    ExceptionBreakpointsAreSet () override;
+    ExceptionBreakpointsAreSet() override;
     
     bool
-    ExceptionBreakpointsExplainStop (lldb::StopInfoSP stop_reason) override;
+    ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override;
     
     lldb::SearchFilterSP
-    CreateExceptionSearchFilter () override;
+    CreateExceptionSearchFilter() override;
     
     uint32_t
-    GetFoundationVersion ();
+    GetFoundationVersion();
     
 protected:
+    // Call CreateInstance instead.
+    AppleObjCRuntime(Process *process);
+
+    bool
+    CalculateHasNewLiteralsAndIndexing() override;
+    
+    static bool
+    AppleIsModuleObjCLibrary(const lldb::ModuleSP &module_sp);
+
+    static ObjCRuntimeVersions
+    GetObjCVersion(Process *process, lldb::ModuleSP &objc_module_sp);
+
+    void
+    ReadObjCLibraryIfNeeded(const ModuleList &module_list);
+
     Address *
     GetPrintForDebuggerAddr();
     
     std::unique_ptr<Address>  m_PrintForDebugger_addr;
     bool m_read_objc_library;
     std::unique_ptr<lldb_private::AppleObjCTrampolineHandler> m_objc_trampoline_handler_ap;
     lldb::BreakpointSP m_objc_exception_bp_sp;
     lldb::ModuleWP m_objc_module_wp;
     std::unique_ptr<FunctionCaller>  m_print_object_caller_up;
     
     llvm::Optional<uint32_t> m_Foundation_major;
-
-    // Call CreateInstance instead.
-    AppleObjCRuntime(Process *process);
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_AppleObjCRuntime_h_
+#endif // liblldb_AppleObjCRuntime_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h

-//===-- AppleObjCRuntimeV1.h ----------------------------------------*- C++ -*-===//
+//===-- AppleObjCRuntimeV1.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 #include "AppleObjCRuntime.h"
 
 namespace lldb_private {
     
 class AppleObjCRuntimeV1 :
         public AppleObjCRuntime
 {
 public:
+    ~AppleObjCRuntimeV1() override = default;
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    static void
+    Initialize();
+    
+    static void
+    Terminate();
+    
+    static lldb_private::LanguageRuntime *
+    CreateInstance(Process *process, lldb::LanguageType language);
+    
+    static lldb_private::ConstString
+    GetPluginNameStatic();
+
     static bool classof(const ObjCLanguageRuntime* runtime)
     {
         switch (runtime->GetRuntimeVersion())
         {
             case ObjCRuntimeVersions::eAppleObjC_V1:
                 return true;
             default:
                 return false;
         }
     }
     
     class ClassDescriptorV1 : public ObjCLanguageRuntime::ClassDescriptor
     {
     public:
         ClassDescriptorV1 (ValueObject &isa_pointer);
         ClassDescriptorV1 (ObjCISA isa, lldb::ProcessSP process_sp);
         
-        virtual ConstString
-        GetClassName ()
+        ~ClassDescriptorV1() override = default;
+
+        ConstString
+        GetClassName() override
         {
             return m_name;
         }
         
-        virtual ClassDescriptorSP
-        GetSuperclass ();
+        ClassDescriptorSP
+        GetSuperclass() override;
         
-        virtual ClassDescriptorSP
-        GetMetaclass () const;
+        ClassDescriptorSP
+        GetMetaclass() const override;
         
-        virtual bool
-        IsValid ()
+        bool
+        IsValid() override
         {
             return m_valid;
         }
         
         // v1 does not support tagged pointers
-        virtual bool
-        GetTaggedPointerInfo (uint64_t* info_bits = NULL,
-                              uint64_t* value_bits = NULL,
-                              uint64_t* payload = NULL)
+        bool
+        GetTaggedPointerInfo(uint64_t* info_bits = nullptr,
+                             uint64_t* value_bits = nullptr,
+                             uint64_t* payload = nullptr) override
         {
             return false;
         }
         
-        virtual uint64_t
-        GetInstanceSize ()
+        uint64_t
+        GetInstanceSize() override
         {
             return m_instance_size;
         }
         
-        virtual ObjCISA
-        GetISA ()
+        ObjCISA
+        GetISA() override
         {
             return m_isa;
         }
         
-        virtual bool
-        Describe (std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
-                  std::function <bool (const char *, const char *)> const &instance_method_func,
-                  std::function <bool (const char *, const char *)> const &class_method_func,
-                  std::function <bool (const char *, const char *, lldb::addr_t, uint64_t)> const &ivar_func) const;
-        
-        virtual
-        ~ClassDescriptorV1 ()
-        {}
-        
+        bool
+        Describe(std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
+                 std::function <bool (const char *, const char *,
+                 lldb::addr_t, uint64_t)> const &ivar_func) const override;
     protected:
         void
         Initialize (ObjCISA isa, lldb::ProcessSP process_sp);
         
     private:
         ConstString m_name;
         ObjCISA m_isa;
         ObjCISA m_parent_isa;
         bool m_valid;
         lldb::ProcessWP m_process_wp;
         uint64_t m_instance_size;
     };
-    
-    virtual ~AppleObjCRuntimeV1() { }
-    
     // These are generic runtime functions:
-    virtual bool
-    GetDynamicTypeAndAddress (ValueObject &in_value, 
-                              lldb::DynamicValueType use_dynamic, 
-                              TypeAndOrName &class_type_or_name, 
-                              Address &address,
-                              Value::ValueType &value_type);
+    bool
+    GetDynamicTypeAndAddress(ValueObject &in_value, 
+                             Value::ValueType &value_type) override;
 
-    virtual UtilityFunction *
-    CreateObjectChecker (const char *);
-
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
-    
-    static void
-    Terminate();
-    
-    static lldb_private::LanguageRuntime *
-    CreateInstance (Process *process, lldb::LanguageType language);
-    
-    static lldb_private::ConstString
-    GetPluginNameStatic();
-    
+    UtilityFunction *
+    CreateObjectChecker(const char *) override;
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual ConstString
-    GetPluginName();
+    ConstString
+    GetPluginName() override;
     
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
     
-    virtual ObjCRuntimeVersions
-    GetRuntimeVersion () const
+    ObjCRuntimeVersions
+    GetRuntimeVersion() const override
     {
         return ObjCRuntimeVersions::eAppleObjC_V1;
     }
     
-    virtual void
-    UpdateISAToDescriptorMapIfNeeded();
+    void
+    UpdateISAToDescriptorMapIfNeeded() override;
     
-    virtual DeclVendor *
-    GetDeclVendor();
+    DeclVendor *
+    GetDeclVendor() override;
 
 protected:
-    virtual lldb::BreakpointResolverSP
-    CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp);
-    
+    lldb::BreakpointResolverSP
+    CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
     
     class HashTableSignature
     {
     public:
         HashTableSignature () :
             m_count (0),
             m_num_buckets (0),
             m_buckets_ptr (LLDB_INVALID_ADDRESS)
public:
         }
 
     protected:
         uint32_t m_count;
         uint32_t m_num_buckets;
         lldb::addr_t m_buckets_ptr;
     };
     
-
     lldb::addr_t
     GetISAHashTablePointer ();
     
     HashTableSignature m_hash_signature;
     lldb::addr_t m_isa_hash_table_ptr;
     std::unique_ptr<DeclVendor> m_decl_vendor_ap;
+
 private:
     AppleObjCRuntimeV1(Process *process);
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_AppleObjCRuntimeV1_h_
+#endif // liblldb_AppleObjCRuntimeV1_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

-//===-- AppleObjCRuntimeV2.h ----------------------------------------*- C++ -*-===//
+//===-- AppleObjCRuntimeV2.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_AppleObjCRuntimeV2_h_
 #define liblldb_AppleObjCRuntimeV2_h_
 
 // C Includes
 // C++ Includes
-
 #include <map>
 #include <memory>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "AppleObjCRuntime.h"
 
 class RemoteNXMapTable;
 
 namespace lldb_private {
 
 class AppleObjCRuntimeV2 :
         public AppleObjCRuntime
 {
 public:
+    ~AppleObjCRuntimeV2() override = default;
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    static void
+    Initialize();
+    
+    static void
+    Terminate();
+    
+    static lldb_private::LanguageRuntime *
+    CreateInstance (Process *process, lldb::LanguageType language);
+    
+    static lldb_private::ConstString
+    GetPluginNameStatic();
+
     static bool classof(const ObjCLanguageRuntime* runtime)
     {
         switch (runtime->GetRuntimeVersion())
         {
             case ObjCRuntimeVersions::eAppleObjC_V2:
                 return true;
             default:
                 return false;
         }
     }
 
-    virtual ~AppleObjCRuntimeV2();
-    
     // These are generic runtime functions:
-    virtual bool
-    GetDynamicTypeAndAddress (ValueObject &in_value, 
-                              lldb::DynamicValueType use_dynamic, 
-                              TypeAndOrName &class_type_or_name, 
-                              Address &address,
-                              Value::ValueType &value_type);
-    
-    virtual UtilityFunction *
-    CreateObjectChecker (const char *);
-
-
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
+    bool
+    GetDynamicTypeAndAddress(ValueObject &in_value,
+                             lldb::DynamicValueType use_dynamic,
+                             TypeAndOrName &class_type_or_name,
+                             Value::ValueType &value_type) override;
     
-    static void
-    Terminate();
-    
-    static lldb_private::LanguageRuntime *
-    CreateInstance (Process *process, lldb::LanguageType language);
-    
-    static lldb_private::ConstString
-    GetPluginNameStatic();
-    
+    UtilityFunction *
+    CreateObjectChecker(const char *) override;
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual ConstString
-    GetPluginName();
+    ConstString
+    GetPluginName() override;
     
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
     
-    virtual ObjCRuntimeVersions
-    GetRuntimeVersion () const
+    ObjCRuntimeVersions
+    GetRuntimeVersion() const override
     {
         return ObjCRuntimeVersions::eAppleObjC_V2;
     }
 
-    virtual size_t
-    GetByteOffsetForIvar (CompilerType &parent_qual_type, const char *ivar_name);
+    size_t
+    GetByteOffsetForIvar(CompilerType &parent_qual_type, const char *ivar_name) override;
+
+    void
+    UpdateISAToDescriptorMapIfNeeded() override;
+    
+    ConstString
+    GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) override;
+    
+    ClassDescriptorSP
+    GetClassDescriptor(ValueObject& in_value) override;
+    
+    ClassDescriptorSP
+    GetClassDescriptorFromISA(ObjCISA isa) override;
+    
+    DeclVendor *
+    GetDeclVendor() override;
+    
+    lldb::addr_t
+    LookupRuntimeSymbol(const ConstString &name) override;
+    
+    EncodingToTypeSP
+    GetEncodingToType() override;
     
-    virtual void
-    UpdateISAToDescriptorMapIfNeeded();
+    TaggedPointerVendor*
+    GetTaggedPointerVendor() override
+    {
+        return m_tagged_pointer_vendor_ap.get();
+    }
     
     // none of these are valid ISAs - we use them to infer the type
     // of tagged pointers - if we have something meaningful to say
     // we report an actual type - otherwise, we just say tagged
     // there is no connection between the values here and the tagged pointers map
     static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA = 1;
     static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSAtom = 2;
     static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSNumber = 3;
     static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDateTS = 4;
     static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSManagedObject = 5;
     static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDate = 6;
 
-    virtual ConstString
-    GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa);
-    
-    virtual ClassDescriptorSP
-    GetClassDescriptor (ValueObject& in_value);
-    
-    virtual ClassDescriptorSP
-    GetClassDescriptorFromISA (ObjCISA isa);
-    
-    virtual DeclVendor *
-    GetDeclVendor();
-    
-    virtual lldb::addr_t
-    LookupRuntimeSymbol (const ConstString &name);
-    
-    virtual EncodingToTypeSP
-    GetEncodingToType ();
-    
-    virtual TaggedPointerVendor*
-    GetTaggedPointerVendor ()
-    {
-        return m_tagged_pointer_vendor_ap.get();
-    }
-    
 protected:
-    virtual lldb::BreakpointResolverSP
-    CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp);
+    lldb::BreakpointResolverSP
+    CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
 
 private:
-    
     class HashTableSignature
     {
     public:
         HashTableSignature ();
 
         bool
         NeedsUpdate (Process *process,
                      AppleObjCRuntimeV2 *runtime,
                      RemoteNXMapTable &hash_table);
         
         void
         UpdateSignature (const RemoteNXMapTable &hash_table);
+
     protected:
         uint32_t m_count;
         uint32_t m_num_buckets;
         lldb::addr_t m_buckets_ptr;
     };
 
     class NonPointerISACache
     {
     public:
         static NonPointerISACache*
         CreateInstance (AppleObjCRuntimeV2& runtime,
                         const lldb::ModuleSP& objc_module_sp);
         
 
         ObjCLanguageRuntime::ClassDescriptorSP
         GetClassDescriptor (ObjCISA isa);
+
     private:
         NonPointerISACache (AppleObjCRuntimeV2& runtime,
                             uint64_t objc_debug_isa_class_mask,
                             uint64_t objc_debug_isa_magic_mask,
                             uint64_t objc_debug_isa_magic_value);
         
         bool
         EvaluateNonPointerISA (ObjCISA isa, ObjCISA& ret_isa);
         
         AppleObjCRuntimeV2&                                         m_runtime;
         std::map<ObjCISA,ObjCLanguageRuntime::ClassDescriptorSP>    m_cache;
         uint64_t                                                    m_objc_debug_isa_class_mask;
         uint64_t                                                    m_objc_debug_isa_magic_mask;
         uint64_t                                                    m_objc_debug_isa_magic_value;
 
         friend class AppleObjCRuntimeV2;
         
         DISALLOW_COPY_AND_ASSIGN(NonPointerISACache);
     };
     
     class TaggedPointerVendorV2 : public ObjCLanguageRuntime::TaggedPointerVendor
     {
     public:
+        ~TaggedPointerVendorV2() override = default;
+
         static TaggedPointerVendorV2*
         CreateInstance (AppleObjCRuntimeV2& runtime,
                         const lldb::ModuleSP& objc_module_sp);
-        
-        virtual
-        ~TaggedPointerVendorV2 () { }
     protected:
         AppleObjCRuntimeV2&                                         m_runtime;
         
         TaggedPointerVendorV2 (AppleObjCRuntimeV2& runtime) :
         TaggedPointerVendor(),
         m_runtime(runtime)
         {
         }
-    private:
-        
+    private:
         DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorV2);
     };
     
     class TaggedPointerVendorRuntimeAssisted : public TaggedPointerVendorV2
     {
     public:
-        virtual bool
-        IsPossibleTaggedPointer (lldb::addr_t ptr);
-        
-        virtual ObjCLanguageRuntime::ClassDescriptorSP
-        GetClassDescriptor (lldb::addr_t ptr);
+        bool
+        IsPossibleTaggedPointer(lldb::addr_t ptr) override;
+        
+        ObjCLanguageRuntime::ClassDescriptorSP
+        GetClassDescriptor(lldb::addr_t ptr) override;
     protected:
         TaggedPointerVendorRuntimeAssisted (AppleObjCRuntimeV2& runtime,
                                              uint64_t objc_debug_taggedpointer_mask,
                                              uint32_t objc_debug_taggedpointer_slot_shift,
                                              uint32_t objc_debug_taggedpointer_slot_mask,
                                              uint32_t objc_debug_taggedpointer_payload_lshift,
                                              uint32_t objc_debug_taggedpointer_payload_rshift,
                                              lldb::addr_t objc_debug_taggedpointer_classes);
protected:
         friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
         
         DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorRuntimeAssisted);
     };
     
     class TaggedPointerVendorLegacy : public TaggedPointerVendorV2
     {
     public:
-        virtual bool
-        IsPossibleTaggedPointer (lldb::addr_t ptr);
-        
-        virtual ObjCLanguageRuntime::ClassDescriptorSP
-        GetClassDescriptor (lldb::addr_t ptr);
+        bool
+        IsPossibleTaggedPointer(lldb::addr_t ptr) override;
+        
+        ObjCLanguageRuntime::ClassDescriptorSP
+        GetClassDescriptor (lldb::addr_t ptr) override;
     protected:
         TaggedPointerVendorLegacy (AppleObjCRuntimeV2& runtime) :
         TaggedPointerVendorV2 (runtime)
         {
         }
         
         friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
         
private:
     std::unique_ptr<NonPointerISACache>     m_non_pointer_isa_cache_ap;
     std::unique_ptr<TaggedPointerVendor>    m_tagged_pointer_vendor_ap;
     EncodingToTypeSP                        m_encoding_to_type_sp;
     bool                                    m_noclasses_warning_emitted;
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_AppleObjCRuntimeV2_h_
+#endif // liblldb_AppleObjCRuntimeV2_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

-//===-- AppleObjCRuntimeV2.cpp --------------------------------------*- C++ -*-===//
+//===-- AppleObjCRuntimeV2.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+#include <stdint.h>
+
+// C++ Includes
 #include <string>
 #include <vector>
-#include <stdint.h>
 
+// Other libraries and framework includes
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclObjC.h"
+
+// Project includes
 #include "lldb/lldb-enumerations.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Symbol/CompilerType.h"
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Error.h"

 #include "lldb/Target/Thread.h"
 
 #include "AppleObjCRuntimeV2.h"
 #include "AppleObjCClassDescriptorV2.h"
 #include "AppleObjCTypeEncodingParser.h"
 #include "AppleObjCDeclVendor.h"
 #include "AppleObjCTrampolineHandler.h"
 
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/DeclObjC.h"
-
 #include "Plugins/Platform/MacOSX/PlatformiOSSimulator.h"
 
-#include <vector>
-
 using namespace lldb;
 using namespace lldb_private;
 
 // 2 second timeout when running utility functions
 #define UTILITY_FUNCTION_TIMEOUT_USEC 2*1000*1000
 
 static const char *g_get_dynamic_class_info_name = "__lldb_apple_objc_v2_get_dynamic_class_info";
 // Testing using the new C++11 raw string literals. If this breaks GCC then we will
if (symbol && symbol->ValueIsAddress())
             return default_value;
         }
     }
     else
     {
         error.SetErrorString("no symbol");
         return default_value;
     }
-
 }
 
 AppleObjCRuntimeV2::AppleObjCRuntimeV2 (Process *process,
                                         const ModuleSP &objc_module_sp) :
     AppleObjCRuntime (process),
     m_get_class_info_code(),
     m_get_class_info_args (LLDB_INVALID_ADDRESS),
     m_get_class_info_args_mutex (Mutex::eMutexTypeNormal),
AppleObjCRuntimeV2::AppleObjCRuntimeV2 (Process *process,
     m_tagged_pointer_vendor_ap(TaggedPointerVendorV2::CreateInstance(*this,objc_module_sp)),
     m_encoding_to_type_sp(),
     m_noclasses_warning_emitted(false)
 {
     static const ConstString g_gdb_object_getClass("gdb_object_getClass");
     m_has_object_getClass = (objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_object_getClass, eSymbolTypeCode) != NULL);
 }
 
-AppleObjCRuntimeV2::~AppleObjCRuntimeV2()
-{
-}
-
 bool
 AppleObjCRuntimeV2::GetDynamicTypeAndAddress (ValueObject &in_value,
                                               DynamicValueType use_dynamic, 
                                               TypeAndOrName &class_type_or_name, 
                                               Address &address,
                                               Value::ValueType &value_type)
 {
     // The Runtime is attached to a particular process, you shouldn't pass in a value from another process.
AppleObjCRuntimeV2::CreateInstance (Process *process, LanguageType language)
     }
     else
         return NULL;
 }
 
 class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed
 {
 public:
-    
     CommandObjectObjC_ClassTable_Dump (CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "dump",
                          "Dump information on Objective-C classes known to the current process.",
                          "language objc class-table dump",
                          eCommandRequiresProcess       |
                          eCommandProcessMustBeLaunched |
                          eCommandProcessMustBePaused   )
     {
     }
-    
-    ~CommandObjectObjC_ClassTable_Dump ()
-    {
-    }
-    
+    ~CommandObjectObjC_ClassTable_Dump() override = default;
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute(Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
         if (objc_runtime)
         {
             auto iterators_pair = objc_runtime->GetDescriptorIteratorPair();
             auto iterator = iterators_pair.first;
             for(; iterator != iterators_pair.second; iterator++)
DoExecute(Args& command, CommandReturnObject &result) override
             return false;
         }
     }
 };
 
 class CommandObjectMultiwordObjC_TaggedPointer_Info : public CommandObjectParsed
 {
 public:
-    
     CommandObjectMultiwordObjC_TaggedPointer_Info (CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "info",
                          "Dump information on a tagged pointer.",
                          "language objc tagged-pointer info",
                          eCommandRequiresProcess       |
                          eCommandProcessMustBeLaunched |
                          eCommandProcessMustBePaused   )
     {
         CommandArgumentEntry arg;
         CommandArgumentData index_arg;
         
         // Define the first (and only) variant of this arg.
         index_arg.arg_type = eArgTypeAddress;
         index_arg.arg_repetition = eArgRepeatPlus;
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (index_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
-    
-    ~CommandObjectMultiwordObjC_TaggedPointer_Info ()
-    {
-    }
-    
+    ~CommandObjectMultiwordObjC_TaggedPointer_Info() override = default;
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute(Args& command, CommandReturnObject &result) override
     {
         if (command.GetArgumentCount() == 0)
         {
             result.AppendError("this command requires arguments");
             result.SetStatus(lldb::eReturnStatusFailed);
             return false;
         }
         
DoExecute(Args& command, CommandReturnObject &result) override
             return false;
         }
     }
 };
 
 class CommandObjectMultiwordObjC_ClassTable : public CommandObjectMultiword
 {
 public:
-    
     CommandObjectMultiwordObjC_ClassTable (CommandInterpreter &interpreter) :
     CommandObjectMultiword (interpreter,
                             "class-table",
                             "A set of commands for operating on the Objective-C class table.",
                             "class-table <subcommand> [<subcommand-options>]")
     {
         LoadSubCommand ("dump",   CommandObjectSP (new CommandObjectObjC_ClassTable_Dump (interpreter)));
     }
-    
-    virtual
-    ~CommandObjectMultiwordObjC_ClassTable ()
-    {
-    }
+    ~CommandObjectMultiwordObjC_ClassTable() override = default;
 };
 
 class CommandObjectMultiwordObjC_TaggedPointer : public CommandObjectMultiword
 {
 public:
     
     CommandObjectMultiwordObjC_TaggedPointer (CommandInterpreter &interpreter) :
     CommandObjectMultiword (interpreter,
                             "tagged-pointer",
                             "A set of commands for operating on Objective-C tagged pointers.",
                             "class-table <subcommand> [<subcommand-options>]")
     {
         LoadSubCommand ("info",   CommandObjectSP (new CommandObjectMultiwordObjC_TaggedPointer_Info (interpreter)));
     }
-    
-    virtual
-    ~CommandObjectMultiwordObjC_TaggedPointer ()
-    {
-    }
+    ~CommandObjectMultiwordObjC_TaggedPointer() override = default;
 };
 
 class CommandObjectMultiwordObjC : public CommandObjectMultiword
 {
 public:
-    
     CommandObjectMultiwordObjC (CommandInterpreter &interpreter) :
     CommandObjectMultiword (interpreter,
                             "objc",
                             "A set of commands for operating on the Objective-C Language Runtime.",
                             "objc <subcommand> [<subcommand-options>]")
     {
         LoadSubCommand ("class-table",   CommandObjectSP (new CommandObjectMultiwordObjC_ClassTable (interpreter)));
         LoadSubCommand ("tagged-pointer",   CommandObjectSP (new CommandObjectMultiwordObjC_TaggedPointer (interpreter)));
     }
-    
-    virtual
-    ~CommandObjectMultiwordObjC ()
-    {
-    }
+    ~CommandObjectMultiwordObjC() override = default;
 };
 
 void
 AppleObjCRuntimeV2::Initialize()
 {
     PluginManager::RegisterPlugin (GetPluginNameStatic(),
                                    "Apple Objective C Language Runtime - Version 2",
                                    CreateInstance,

 
 lldb_private::ConstString
 AppleObjCRuntimeV2::GetPluginNameStatic()
 {
     static ConstString g_name("apple-objc-v2");
     return g_name;
 }
 
-
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 lldb_private::ConstString
 AppleObjCRuntimeV2::GetPluginName()
 {
     return GetPluginNameStatic();
 }
if (class_name && class_name[0] && ivar_name && ivar_name[0])
             ivar_offset = m_process->ReadUnsignedIntegerFromMemory (ivar_offset_address,
                                                                     4,
                                                                     LLDB_INVALID_IVAR_OFFSET,
                                                                     error);
     }
     return ivar_offset;
 }
 
-
 // tagged pointers are special not-a-real-pointer values that contain both type and value information
 // this routine attempts to check with as little computational effort as possible whether something
 // could possibly be a tagged pointer - false positives are possible but false negatives shouldn't
 bool
 AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr)
 {
     if (!m_tagged_pointer_vendor_ap)
         return false;
     return m_tagged_pointer_vendor_ap->IsPossibleTaggedPointer(ptr);
 }
 
 class RemoteNXMapTable
 {
 public:
-    
     RemoteNXMapTable () :
         m_count (0),
         m_num_buckets_minus_one (0),
         m_buckets_ptr (LLDB_INVALID_ADDRESS),
         m_process (NULL),
         m_end_iterator (*this, -1),
         m_load_addr (LLDB_INVALID_ADDRESS),
         m_map_pair_size (0),
public:
             std::string key_string;
             
             m_parent.m_process->ReadCStringFromMemory(key, key_string, err);
             if (!err.Success())
                 return element();
             
             return element(ConstString(key_string.c_str()), (ObjCLanguageRuntime::ObjCISA)value);
         }
+
     private:
         void AdvanceToValidIndex ()
         {
             if (m_index == -1)
                 return;
             
             const lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
             const size_t map_pair_size = m_parent.m_map_pair_size;
private:
     lldb::addr_t m_buckets_ptr;
     lldb_private::Process *m_process;
     const_iterator m_end_iterator;
     lldb::addr_t m_load_addr;
     size_t m_map_pair_size;
     lldb::addr_t m_invalid_key;
 };
 
-
-
 AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() :
     m_count (0),
     m_num_buckets (0),
     m_buckets_ptr (0)
 {
 }
 
 void
else
         if (!get_class_info_function)
         {
             if (log)
                 log->Printf ("Failed to get implementation lookup function caller: %s.", errors.GetData());
             return false;
         }
         arguments = get_class_info_function->GetArgumentValues();
     }
-    
-    
-    
-    
     errors.Clear();
     
     const uint32_t class_info_byte_size = addr_size + 4;
     const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
     lldb::addr_t class_infos_addr = process->AllocateMemory(class_infos_byte_size,
                                                             ePermissionsReadable | ePermissionsWritable,
                                                             err);
     
#endif
     }
     
     // Deallocate the memory we allocated for the ClassInfo array
     process->DeallocateMemory(class_infos_addr);
     
     return DescriptorMapUpdateResult(success, any_found);
 }
 
-
 bool
 AppleObjCRuntimeV2::UpdateISAToDescriptorMapFromMemory (RemoteNXMapTable &hash_table)
 {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     
     Process *process = GetProcess();
 
     if (process == NULL)
if (process)
         if (!m_loaded_objc_opt)
         {
             DescriptorMapUpdateResult shared_cache_update_result = UpdateISAToDescriptorMapSharedCache();
             if (!shared_cache_update_result.any_found)
                 WarnIfNoClassesCached ();
             else
                 m_loaded_objc_opt = true;
         }
-        
     }
     else
     {
         m_isa_to_descriptor_stop_id = UINT32_MAX;
     }
 }
 
 void

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h

 //===-- AppleObjCTypeEncodingParser.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_AppleObjCTypeEncodingParser_h_
 #define liblldb_AppleObjCTypeEncodingParser_h_
 
 // C Includes
 // C++ Includes
-
 // Other libraries and framework includes
+#include "clang/AST/ASTContext.h"
 
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 
-#include "clang/AST/ASTContext.h"
-
 namespace lldb_utility {
     class StringLexer;
 }
 
 namespace lldb_private {
 
     class AppleObjCTypeEncodingParser : public ObjCLanguageRuntime::EncodingToType
     {
     public:
         AppleObjCTypeEncodingParser (ObjCLanguageRuntime& runtime);
-        virtual CompilerType RealizeType (clang::ASTContext &ast_ctx, const char* name, bool for_expression);
-        virtual ~AppleObjCTypeEncodingParser() {}
-        
+        ~AppleObjCTypeEncodingParser() override = default;
+        
+        CompilerType RealizeType(clang::ASTContext &ast_ctx, const char* name, bool for_expression) override;
     private:
         struct StructElement {
             std::string name;
             clang::QualType type;
             uint32_t bitfield;
             
             StructElement ();
             ~StructElement () = default;
private:
         std::string
         ReadQuotedString(lldb_utility::StringLexer& type);
         
         ObjCLanguageRuntime& m_runtime;
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_AppleObjCTypeEncodingParser_h_
+#endif // liblldb_AppleObjCTypeEncodingParser_h_

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h

-//===-- AppleThreadPlanStepThroughObjCTrampoline.h --------------------------*- C++ -*-===//
+//===-- AppleThreadPlanStepThroughObjCTrampoline.h --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 #include "AppleObjCTrampolineHandler.h"
 
 namespace lldb_private 
 {
 
 class AppleThreadPlanStepThroughObjCTrampoline : public ThreadPlan
 {
 public:
-  //------------------------------------------------------------------
-  // Constructors and Destructors
-  //------------------------------------------------------------------
-  AppleThreadPlanStepThroughObjCTrampoline(Thread &thread, 
+    AppleThreadPlanStepThroughObjCTrampoline(Thread &thread, 
                                              AppleObjCTrampolineHandler *trampoline_handler, 
                                              ValueList &values,
                                              lldb::addr_t isa_addr,
                                              lldb::addr_t sel_addr,
                                              bool stop_others);
-    
-  virtual ~AppleThreadPlanStepThroughObjCTrampoline();
+    ~AppleThreadPlanStepThroughObjCTrampoline() override;
 
-    virtual void
-    GetDescription (Stream *s,
-                    lldb::DescriptionLevel level);
+    static bool
+    PreResumeInitializeFunctionCaller(void *myself);
+
+    void
+    GetDescription(Stream *s,
+                   lldb::DescriptionLevel level) override;
                     
-    virtual bool
-    ValidatePlan (Stream *error);
+    bool
+    ValidatePlan(Stream *error) override;
 
-    virtual lldb::StateType
-    GetPlanRunState ();
+    lldb::StateType
+    GetPlanRunState() override;
 
-    virtual bool
-    ShouldStop (Event *event_ptr);
+    bool
+    ShouldStop(Event *event_ptr) override;
     
-    virtual bool
-    StopOthers()
+    bool
+    StopOthers() override
     {
         return m_stop_others;
     }
 
     // The base class MischiefManaged does some cleanup - so you have to call it
     // in your MischiefManaged derived class.
-    virtual bool
-    MischiefManaged ();
-    
-    virtual void
-    DidPush();
-    
-    static bool
-    PreResumeInitializeFunctionCaller(void *myself);
-
-    virtual bool
-    WillStop();
+    bool
+    MischiefManaged() override;
     
+    void
+    DidPush() override;
     
+    bool
+    WillStop() override;
 
 protected:
-  //------------------------------------------------------------------
-  // Classes that inherit from AppleThreadPlanStepThroughObjCTrampoline can see and modify these
-  //------------------------------------------------------------------
-    virtual bool
-    DoPlanExplainsStop (Event *event_ptr);
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
   
 private:
     bool
     InitializeFunctionCaller ();
 
-  //------------------------------------------------------------------
-  // For AppleThreadPlanStepThroughObjCTrampoline only
-  //------------------------------------------------------------------
     AppleObjCTrampolineHandler *m_trampoline_handler; // FIXME - ensure this doesn't go away on us?  SP maybe?
     lldb::addr_t m_args_addr;     // Stores the address for our step through function result structure.
     //lldb::addr_t m_object_addr;  // This is only for Description.
     ValueList    m_input_values;
     lldb::addr_t m_isa_addr;     // isa_addr and sel_addr are the keys we will use to cache the implementation.
     lldb::addr_t m_sel_addr;
     lldb::ThreadPlanSP m_func_sp;       // This is the function call plan.  We fill it at start, then set it
                                         // to NULL when this plan is done.  That way we know to go to:
     lldb::ThreadPlanSP m_run_to_sp;     // The plan that runs to the target.
     FunctionCaller *m_impl_function;  // This is a pointer to a impl function that
                                      // is owned by the client that pushes this plan.
     bool m_stop_others;
 };
 
 } // namespace lldb_private
 
-#endif  // lldb_AppleThreadPlanStepThroughObjCTrampoline_h_
+#endif // lldb_AppleThreadPlanStepThroughObjCTrampoline_h_