[LLDB] Fix Clang-tidy modernize-use-override warnings in remaining files in include/lldb/Core and Target, source/Plugins/SymbolFile and tools/lldb-mi, unify closing inclusion guards

[Eugene.Zelenko]

Summary

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

Please check it in if it's OK, because I don't have SVN write access.

[brucem]

This doesn't currently apply. (Probably true of your others as well.) Please update.

include/lldb/Core/ValueObjectRegister.h

 class ValueObjectRegisterContext : public ValueObject
 {
 public:
+    ~ValueObjectRegisterContext() override;
 
-    virtual
-    ~ValueObjectRegisterContext();
+    uint64_t
+    GetByteSize() override;
 
-    virtual uint64_t
-    GetByteSize();
-
-    virtual lldb::ValueType
-    GetValueType () const
+    lldb::ValueType
+    GetValueType () const override
     {
         return lldb::eValueTypeRegisterSet;
     }
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
     
-    virtual ConstString
-    GetQualifiedTypeName();
+    ConstString
+    GetQualifiedTypeName() override;
     
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual ValueObject *
-    CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
+    ValueObject *
+    CreateChildAtIndex(size_t idx, bool synthetic_array_member, int32_t synthetic_index) override;
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     lldb::RegisterContextSP m_reg_ctx_sp;
 

     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t set_idx);
 
-    virtual
-    ~ValueObjectRegisterSet();
+    ~ValueObjectRegisterSet() override;
 
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
 
-    virtual lldb::ValueType
-    GetValueType () const
+    lldb::ValueType
+    GetValueType() const override
     {
         return lldb::eValueTypeRegisterSet;
     }
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
     
-    virtual ConstString
-    GetQualifiedTypeName();
+    ConstString
+    GetQualifiedTypeName() override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual ValueObject *
-    CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
+    ValueObject *
+    CreateChildAtIndex(size_t idx, bool synthetic_array_member, int32_t synthetic_index) override;
     
-    virtual lldb::ValueObjectSP
-    GetChildMemberWithName (const ConstString &name, bool can_create);
+    lldb::ValueObjectSP
+    GetChildMemberWithName(const ConstString &name, bool can_create) override;
 
-    virtual size_t
-    GetIndexOfChildWithName (const ConstString &name);
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override;
 
-
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     lldb::RegisterContextSP m_reg_ctx_sp;
     const RegisterSet *m_reg_set;

     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
 
-    virtual
-    ~ValueObjectRegister();
+    ~ValueObjectRegister() override;
 
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
 
-    virtual lldb::ValueType
-    GetValueType () const
+    lldb::ValueType
+    GetValueType() const override
     {
         return lldb::eValueTypeRegister;
     }
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
     
-    virtual bool
-    SetValueFromCString (const char *value_str, Error& error);
+    bool
+    SetValueFromCString(const char *value_str, Error& error) override;
     
-    virtual bool
-    SetData (DataExtractor &data, Error &error);
+    bool
+    SetData(DataExtractor &data, Error &error) override;
 
-    virtual bool
-    ResolveValue (Scalar &scalar);
+    bool
+    ResolveValue(Scalar &scalar) override;
     
-    virtual void
-    GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat = eGetExpressionPathFormatDereferencePointers);
+    void
+    GetExpressionPath(Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat = eGetExpressionPathFormatDereferencePointers) override;
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     lldb::RegisterContextSP m_reg_ctx_sp;
     RegisterInfo m_reg_info;

     ConstructObject (uint32_t reg_num);
     
     friend class ValueObjectRegisterSet;
+
     ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
     ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
 

 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectRegister_h_
+#endif // liblldb_ValueObjectRegister_h_

include/lldb/Core/ValueObjectSyntheticFilter.h

 class ValueObjectSynthetic : public ValueObject
 {
 public:
-    virtual
-    ~ValueObjectSynthetic();
+    ~ValueObjectSynthetic() override;
 
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
     
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
     
-    virtual ConstString
-    GetQualifiedTypeName();
+    ConstString
+    GetQualifiedTypeName() override;
     
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() override;
 
-    virtual bool
-    MightHaveChildren();
+    bool
+    MightHaveChildren() override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
     
-    virtual lldb::ValueObjectSP
-    GetChildAtIndex (size_t idx, bool can_create);
+    lldb::ValueObjectSP
+    GetChildAtIndex(size_t idx, bool can_create) override;
     
-    virtual lldb::ValueObjectSP
-    GetChildMemberWithName (const ConstString &name, bool can_create);
+    lldb::ValueObjectSP
+    GetChildMemberWithName(const ConstString &name, bool can_create) override;
     
-    virtual size_t
-    GetIndexOfChildWithName (const ConstString &name);
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override;
 
-    virtual lldb::ValueObjectSP
-    GetDynamicValue (lldb::DynamicValueType valueType);
+    lldb::ValueObjectSP
+    GetDynamicValue(lldb::DynamicValueType valueType) override;
     
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
     
-    virtual bool
-    HasSyntheticValue()
+    bool
+    HasSyntheticValue() override
     {
         return false;
     }
     
-    virtual bool
-    IsSynthetic() { return true; }
+    bool
+    IsSynthetic() override
+    {
+        return true;
+    }
     
-    virtual void
-    CalculateSyntheticValue (bool use_synthetic)
+    void
+    CalculateSyntheticValue(bool use_synthetic) override
     {
     }
     
-    virtual bool
-    IsDynamic ()
+    bool
+    IsDynamic() override
     {
         if (m_parent)
             return m_parent->IsDynamic();

             return false;
     }
     
-    virtual lldb::ValueObjectSP
-    GetStaticValue ()
+    lldb::ValueObjectSP
+    GetStaticValue() override
     {
         if (m_parent)
             return m_parent->GetStaticValue();

     }
 
     virtual ValueObject *
-    GetParent()
+    GetParent() override
     {
         if (m_parent)
             return m_parent->GetParent();

             return NULL;
     }
 
-    virtual const ValueObject *
-    GetParent() const
+    const ValueObject *
+    GetParent() const override
     {
         if (m_parent)
             return m_parent->GetParent();

             return NULL;
     }
     
-    virtual lldb::ValueObjectSP
-    GetNonSyntheticValue ();
+    lldb::ValueObjectSP
+    GetNonSyntheticValue() override;
     
-    virtual bool
-    CanProvideValue ();
+    bool
+    CanProvideValue() override;
     
-    virtual bool
-    DoesProvideSyntheticValue ()
+    bool
+    DoesProvideSyntheticValue() override
     {
         return (UpdateValueIfNeeded(), m_provides_value == eLazyBoolYes);
     }
     
-    virtual bool
-    GetIsConstant () const
+    bool
+    GetIsConstant() const override
     {
         return false;
     }
 
-    virtual bool
-    SetValueFromCString (const char *value_str, Error& error);
+    bool
+    SetValueFromCString(const char *value_str, Error& error) override;
     
-    virtual void
-    SetFormat (lldb::Format format);
+    void
+    SetFormat(lldb::Format format) override;
     
-    virtual bool
-    GetDeclaration (Declaration &decl);
+    bool
+    GetDeclaration(Declaration &decl) override;
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual LazyBool
-    CanUpdateWithInvalidExecutionContext ()
+    LazyBool
+    CanUpdateWithInvalidExecutionContext() override
     {
         return eLazyBoolYes;
     }
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
     
     virtual void
     CreateSynthFilter ();

     
 private:
     friend class ValueObject;
+
     ValueObjectSynthetic (ValueObject &parent, lldb::SyntheticChildrenSP filter);
     
     void

 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectSyntheticFilter_h_
+#endif // liblldb_ValueObjectSyntheticFilter_h_

include/lldb/Symbol/ClangASTContext.h

                  lldb::offset_t data_offset,
                  size_t data_byte_size) override;
     
-    virtual void
-    DumpTypeDescription (void *type) override; // Dump to stdout
+    void
+    DumpTypeDescription(void *type) override; // Dump to stdout
     
     void
     DumpTypeDescription (void *type, Stream *s) override;

include/lldb/Target/ThreadPlanStepOverRange.h

                              lldb::RunMode stop_others,
                              LazyBool step_out_avoids_no_debug);
                              
-    virtual ~ThreadPlanStepOverRange ();
+    ~ThreadPlanStepOverRange() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ShouldStop (Event *event_ptr);
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ShouldStop(Event *event_ptr) override;
     
 protected:
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoPlanExplainsStop(Event *event_ptr) override;
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
     
-    virtual void
-    SetFlagsToDefault ()
+    void
+    SetFlagsToDefault() override
     {
         GetFlags().Set(ThreadPlanStepOverRange::s_default_flag_values);
     }
-    
-    
-    
 private:
 
     static uint32_t s_default_flag_values;

     bool m_first_resume;
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepOverRange);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepOverRange_h_
+#endif // liblldb_ThreadPlanStepOverRange_h_

include/lldb/Target/ThreadPlanStepRange.h

                          lldb::RunMode stop_others,
                          bool given_ranges_only = false);
 
-    virtual ~ThreadPlanStepRange ();
+    ~ThreadPlanStepRange() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level) = 0;
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr) = 0;
-    virtual Vote ShouldReportStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual void DidPush ();
-    virtual bool IsPlanStale ();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override = 0;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override = 0;
+    Vote ShouldReportStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    void DidPush() override;
+    bool IsPlanStale() override;
 
-
     void AddRange(const AddressRange &new_range);
 
 protected:

 private:
     std::vector<lldb::DisassemblerSP> m_instruction_ranges;
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepRange);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepRange_h_
+#endif // liblldb_ThreadPlanStepRange_h_

include/lldb/Target/ThreadPlanStepThrough.h

 class ThreadPlanStepThrough : public ThreadPlan
 {
 public:
-    virtual ~ThreadPlanStepThrough ();
+    ~ThreadPlanStepThrough() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual void DidPush();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    void DidPush() override;
 
 protected:
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoPlanExplainsStop(Event *event_ptr) override;
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 
     ThreadPlanStepThrough (Thread &thread,
                            StackID &return_stack_id,

     bool              m_stop_others;
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepThrough);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepThrough_h_
+#endif // liblldb_ThreadPlanStepThrough_h_

include/lldb/Target/ThreadPlanStepUntil.h

 
 namespace lldb_private {
 
-
 class ThreadPlanStepUntil : public ThreadPlan
 {
 public:
-    virtual ~ThreadPlanStepUntil ();
+    ~ThreadPlanStepUntil() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
 
 protected:
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
+    bool DoPlanExplainsStop(Event *event_ptr) override;
 
     ThreadPlanStepUntil (Thread &thread,
                          lldb::addr_t *address_list,

     // from step in.
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepUntil);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepUntil_h_
+#endif // liblldb_ThreadPlanStepUntil_h_

include/lldb/Target/ThreadPlanTracer.h

         eCheckFrames,
         ePython
     } ThreadPlanTracerStyle;
+
     ThreadPlanTracer (Thread &thread, lldb::StreamSP &stream_sp);    
     ThreadPlanTracer (Thread &thread);
         

     
     virtual void TracingStarted ()
     {
-    
     }
     
     virtual void TracingEnded ()
     {
-    
     }
     
     bool

 
     Stream *
     GetLogStream ();
-    
-    
-    
     virtual void Log();
     
 private:

 public:
     ThreadPlanAssemblyTracer (Thread &thread, lldb::StreamSP &stream_sp);    
     ThreadPlanAssemblyTracer (Thread &thread);    
-    virtual ~ThreadPlanAssemblyTracer ();
-    virtual void TracingStarted ();
-    virtual void TracingEnded ();
-    virtual void Log();
+
+    ~ThreadPlanAssemblyTracer() override;
+
+    void TracingStarted() override;
+    void TracingEnded() override;
+    void Log() override;
+
 private:
     
     Disassembler *

 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanTracer_h_
+#endif // liblldb_ThreadPlanTracer_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 public:
     DWARFASTParserClang (lldb_private::ClangASTContext &ast);
 
-    virtual ~DWARFASTParserClang ();
+    ~DWARFASTParserClang() override;
 
     lldb::TypeSP
     ParseTypeFromDWARF (const lldb_private::SymbolContext& sc,

                         bool *type_is_new_ptr) override;
 
 
-    virtual lldb_private::Function *
+    lldb_private::Function *
     ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
                             const DWARFDIE &die) override;
 
-    virtual bool
+    bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &clang_type) override;
 
-    virtual lldb_private::CompilerDeclContext
+    lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) override;
 
-    virtual lldb_private::CompilerDeclContext
+    lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) override;
 
     bool

                      llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets);
+
 protected:
 
     class DelayedAddObjCClassProperty;

                           std::vector<clang::ParmVarDecl*>& function_param_decls,
                           unsigned &type_quals);
 
-
     void
     ParseChildArrayInfo (const lldb_private::SymbolContext& sc,
                          const DWARFDIE &parent_die,

                          uint32_t& byte_stride,
                          uint32_t& bit_stride);
 
-
     size_t
     ParseChildEnumerators (const lldb_private::SymbolContext& sc,
                            lldb_private::CompilerType &clang_type,

     RecordDeclToLayoutMap m_record_decl_to_layout_map;
 };
 
-#endif  // SymbolFileDWARF_DWARFASTParserClang_h_
+#endif // SymbolFileDWARF_DWARFASTParserClang_h_

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

         // @implementation for class
         eTypeFlagClassIsImplementation  = ( 1u << 1 )
     };
-    
 
     static void
     ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,

         }
         return "<invalid>";
     }
+
     struct Prologue
     {
         // DIE offset base so die offsets in hash_data can be CU relative

             AppendAtom (eAtomTypeDIEOffset, DW_FORM_data4);
         }
         
-        virtual ~Prologue()
-        {
-        }
+        virtual ~Prologue() = default;
 
         void
         ClearAtoms ()

                 case DW_FORM_ref8:
                     min_hash_data_byte_size += 8; 
                     break;
-                    
             }
         }
         

         Header (dw_offset_t _die_base_offset = 0)
         {
         }
-        
-        virtual 
-        ~Header()
-        {
-        }
 
-        virtual size_t
-        GetByteSize (const HeaderData &header_data)
+        ~Header() override = default;
+
+        size_t
+        GetByteSize(const HeaderData &header_data) override
         {
             return header_data.GetByteSize();
         }

         //        virtual void
         //        Dump (std::ostream* ostrm_ptr);        
         //        
-        virtual lldb::offset_t
-        Read (lldb_private::DataExtractor &data, lldb::offset_t offset)
+        lldb::offset_t
+        Read(lldb_private::DataExtractor &data, lldb::offset_t offset) override
         {
             offset = MappedHash::Header<Prologue>::Read (data, offset);
             if (offset != UINT32_MAX)

             m_name (name)
         {
         }
-    
-        virtual 
-        ~MemoryTable ()
-        {
-        }
 
-        virtual const char *
-        GetStringForKeyType (KeyType key) const
+        ~MemoryTable() override = default;
+
+        const char *
+        GetStringForKeyType(KeyType key) const override
         {
             // The key in the DWARF table is the .debug_str offset for the string
             return m_string_table.PeekCStr (key);
         }
         
-        virtual bool
-        ReadHashData (uint32_t hash_data_offset,
-                      HashData &hash_data) const
+        bool
+        ReadHashData(uint32_t hash_data_offset,
+         HashData &hash_data) const override
         {
             lldb::offset_t offset = hash_data_offset;
             offset += 4; // Skip string table offset that contains offset of hash name in .debug_str

             return true;
         }
 
-        virtual Result
-        GetHashDataForName (const char *name,
-                            lldb::offset_t* hash_data_offset_ptr,
-                            Pair &pair) const
+        Result
+        GetHashDataForName(const char *name,
+         lldb::offset_t* hash_data_offset_ptr,
+         Pair &pair) const override
         {
             pair.key = m_data.GetU32 (hash_data_offset_ptr);
             pair.value.clear();

     };
 };
 
-
-#endif  // SymbolFileDWARF_HashedNameToDIE_h_
+#endif // SymbolFileDWARF_HashedNameToDIE_h_

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

     //------------------------------------------------------------------
     SymbolFileSymtab(lldb_private::ObjectFile* obj_file);
 
-    virtual
-    ~SymbolFileSymtab();
+    ~SymbolFileSymtab() override;
 
-    virtual uint32_t        CalculateAbilities ();
+    uint32_t
+    CalculateAbilities() override;
 
     //------------------------------------------------------------------
     // Compile Unit function calls
     //------------------------------------------------------------------
-    virtual uint32_t
-    GetNumCompileUnits();
+    uint32_t
+    GetNumCompileUnits() override;
 
-    virtual lldb::CompUnitSP
-    ParseCompileUnitAtIndex(uint32_t index);
+    lldb::CompUnitSP
+    ParseCompileUnitAtIndex(uint32_t index) override;
 
-    virtual lldb::LanguageType
-    ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc);
+    lldb::LanguageType
+    ParseCompileUnitLanguage(const lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseCompileUnitFunctions(const lldb_private::SymbolContext& sc) override;
 
-    virtual bool
-    ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc);
+    bool
+    ParseCompileUnitLineTable(const lldb_private::SymbolContext& sc) override;
 
-    virtual bool
-    ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files);
+    bool
+    ParseCompileUnitSupportFiles(const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files) override;
     
-    virtual bool
-    ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules);
+    bool
+    ParseImportedModules(const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) override;
 
-    virtual size_t
-    ParseFunctionBlocks (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseFunctionBlocks(const lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    ParseTypes (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseTypes(const lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    ParseVariablesForContext (const lldb_private::SymbolContext& sc);
+    size_t
+    ParseVariablesForContext(const lldb_private::SymbolContext& sc) override;
 
-    virtual lldb_private::Type*
-    ResolveTypeUID(lldb::user_id_t type_uid);
+    lldb_private::Type*
+    ResolveTypeUID(lldb::user_id_t type_uid) override;
 
-    virtual bool
-    CompleteType (lldb_private::CompilerType& clang_type);
+    bool
+    CompleteType(lldb_private::CompilerType& clang_type) override;
 
-    virtual uint32_t
-    ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc);
+    uint32_t
+    ResolveSymbolContext(const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc) override;
 
-    virtual size_t
-    GetTypes (lldb_private::SymbolContextScope *sc_scope,
-              uint32_t type_mask,
-              lldb_private::TypeList &type_list);
+    size_t
+    GetTypes(lldb_private::SymbolContextScope *sc_scope,
+       uint32_t type_mask,
+       lldb_private::TypeList &type_list) override;
 
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual lldb_private::ConstString
-    GetPluginName();
+    lldb_private::ConstString
+    GetPluginName() override;
 
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 
 protected:
     typedef std::map<lldb_private::ConstString, lldb::TypeSP> TypeMap;

     TypeMap m_objc_class_types;
 
     lldb_private::ClangASTContext &
-    GetClangASTContext ();
+    GetClangASTContext() override;
     
 private:
     DISALLOW_COPY_AND_ASSIGN (SymbolFileSymtab);
 };
 
-
-#endif  // liblldb_SymbolFileSymtab_h_
+#endif // liblldb_SymbolFileSymtab_h_

tools/lldb-mi/MICmdArgSet.h

 
     // Overrideable:
   public:
-    /* dtor */ virtual ~CMICmdArgSet();
+    ~CMICmdArgSet() override;
 
     // Methods:
   private:

tools/lldb-mi/MICmdArgValBase.h

 
     // Overrideable:
   public:
-    /* dtor */ virtual ~CMICmdArgValBaseTemplate();
+    ~CMICmdArgValBaseTemplate() override;
 
     // Attributes:
   protected:

tools/lldb-mi/MICmdBase.h

     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual const SMICmdData &GetCmdData() const;
-    virtual const CMIUtilString &GetErrorDescription() const;
-    virtual void SetCmdData(const SMICmdData &vCmdData);
-    virtual void CmdFinishedTellInvoker() const;
-    virtual const CMIUtilString &GetMIResultRecord() const;
-    virtual const CMIUtilString &GetMIResultRecordExtra() const;
-    virtual bool HasMIResultRecordExtra() const;
-    virtual bool ParseArgs();
+    const SMICmdData &GetCmdData() const override;
+    const CMIUtilString &GetErrorDescription() const override;
+    void SetCmdData(const SMICmdData &vCmdData) override;
+    void CmdFinishedTellInvoker() const override;
+    const CMIUtilString &GetMIResultRecord() const override;
+    const CMIUtilString &GetMIResultRecordExtra() const override;
+    bool HasMIResultRecordExtra() const override;
+    bool ParseArgs() override;
     // From CMICmdFactory::ICmd
-    virtual const CMIUtilString &GetMiCmd() const;
-    virtual CMICmdFactory::CmdCreatorFnPtr GetCmdCreatorFn() const;
+    const CMIUtilString &GetMiCmd() const override;
+    CMICmdFactory::CmdCreatorFnPtr GetCmdCreatorFn() const override;
 
     virtual MIuint GetGUID();
 
     // Overrideable:
   public:
-    /* dtor */ virtual ~CMICmdBase();
+    ~CMICmdBase() override;
     virtual bool GetExitAppOnCommandFailure() const;
 
     // Methods: