[LLDB] Fix Clang-tidy misc-use-override warnings in some files in include/lldb/Core; other minor fixes.

[Eugene.Zelenko]

Summary

This is second attempt based on current code.

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]

I'd like to hear from @clayborg about the whitespace changes here.

[Eugene.Zelenko]

I make whitespaces more consistent.

Space between function names and round bracket is consistent with Clang-format settings for LLDB.

[clayborg]

We are pretty inconsistent with the space after a function name and before the ( so I don't mind.

[amccarth]

There was an lldb-dev thread from February 9, where it seemed to be agreed
that lldb code should be more like llvm code, in particular with the spaces
between the function names and the opening parens. I've been omitting the
spaces in new code since then.

lldb/trunk/include/lldb/Core/Communication.h

FLAGS_ANONYMOUS_ENUM()
         eBroadcastBitNoMorePendingInput     = (1u << 5), ///< Sent by the read thread to indicate all pending input has been processed.
         kLoUserBroadcastBit                 = (1u << 16),///< Subclasses can used bits 31:16 for any needed events.
         kHiUserBroadcastBit                 = (1u << 31),
         eAllEventBits                       = 0xffffffff
     };
 
     typedef void (*ReadThreadBytesReceived) (void *baton, const void *src, size_t src_len);
 
-
     //------------------------------------------------------------------
     /// Construct the Communication object with the specified name for
     /// the Broadcaster that this object inherits from.
     ///
     /// @param[in] broadcaster_name
     ///     The name of the broadcaster object.  This name should be as
     ///     complete as possible to uniquely identify this object. The
     ///     broadcaster name can be updated after the connect function
     ///     is called.
     //------------------------------------------------------------------
     Communication(const char * broadcaster_name);
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual since this class gets subclassed.
     //------------------------------------------------------------------
-    virtual
-    ~Communication();
+    ~Communication() override;
 
     void
     Clear ();
 
     //------------------------------------------------------------------
     /// Connect using the current connection by passing \a url to its
     /// connect function.
     /// string.
public:
     bool
     HasConnection () const;
     
     lldb_private::Connection *
     GetConnection ()
     {
         return m_connection_sp.get();
     }
+
     //------------------------------------------------------------------
     /// Read bytes from the current connection.
     ///
     /// If no read thread is running, this function call the
     /// connection's Connection::Read(...) function to get any available.
     ///
     /// If a read thread has been started, this function will check for
     /// any cached bytes that have already been read and return any
public:
     void
     SetCloseOnEOF (bool b)
     { 
         m_close_on_eof = b;
     }
 
     static ConstString &GetStaticBroadcasterClass ();
 
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }
 
 private:
     //------------------------------------------------------------------
     // For Communication only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (Communication);
 
-
 protected:
     lldb::ConnectionSP m_connection_sp; ///< The connection that is current in use by this communications class.
     HostThread m_read_thread;           ///< The read thread handle in case we need to cancel the thread.
     std::atomic<bool> m_read_thread_enabled;
     std::atomic<bool> m_read_thread_did_exit;
     std::string m_bytes;    ///< A buffer to cache bytes read in the ReadThread function.
     Mutex m_bytes_mutex;    ///< A mutex to protect multi-threaded access to the cached bytes.
     Mutex m_write_mutex;    ///< Don't let multiple threads write at the same time...
     Mutex m_synchronize_mutex;
     ReadThreadBytesReceived m_callback;
     void *m_callback_baton;
     bool m_close_on_eof;
 
     size_t
     ReadFromConnection (void *dst, 
                         size_t dst_len, 
                         uint32_t timeout_usec,
                         lldb::ConnectionStatus &status, 
                         Error *error_ptr);
+
     //------------------------------------------------------------------
     /// Append new bytes that get read from the read thread into the
     /// internal object byte cache. This will cause a \b
     /// eBroadcastBitReadThreadGotBytes event to be broadcast if \a
     /// broadcast is true.
     ///
     /// Subclasses can override this function in order to inspect the
     /// received data and check if a packet is available.
protected:
     ///     The number of bytes extracted from the data cache.
     //------------------------------------------------------------------
     size_t
     GetCachedBytes (void *dst, size_t dst_len);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Communication_h_
+#endif // liblldb_Communication_h_

lldb/trunk/include/lldb/Core/Debugger.h

 //===-- Debugger.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_Debugger_h_
 #define liblldb_Debugger_h_
-#if defined(__cplusplus)
-
 
 #include <stdint.h>
 
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/UserID.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/TargetList.h"
 
 namespace llvm
 {
 namespace sys
 {
 class DynamicLibrary;
-}
-}
+} // namespace sys
+} // namespace llvm
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class Debugger Debugger.h "lldb/Core/Debugger.h"
 /// @brief A class to manage flag bits.
 ///
 /// Provides a global root objects for the debugger core.
 //----------------------------------------------------------------------
 
-
 class Debugger :
     public std::enable_shared_from_this<Debugger>,
     public UserID,
     public Properties,
     public BroadcasterManager
 {
 friend class SourceManager;  // For GetSourceFileCache.
 
public:
     SettingsInitialize ();
     
     static void
     SettingsTerminate ();
     
     static void
     Destroy (lldb::DebuggerSP &debugger_sp);
 
-    virtual
-    ~Debugger ();
+    ~Debugger() override;
     
     void Clear();
 
     bool
     GetAsyncExecution ();
 
     void
     SetAsyncExecution (bool async);
public:
     }
 
     lldb::StreamFileSP
     GetErrorFile ()
     {
         return m_error_file_sp;
     }
 
-    
-    
     void
     SetInputFileHandle (FILE *fh, bool tranfer_ownership);
 
     void
     SetOutputFileHandle (FILE *fh, bool tranfer_ownership);
 
     void
     SetErrorFileHandle (FILE *fh, bool tranfer_ownership);
public:
     SetCloseInputOnEOF (bool b);
     
     bool
     EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream);
 
     void
     SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton);
     
-
     //----------------------------------------------------------------------
     // Properties Functions
     //----------------------------------------------------------------------
     enum StopDisassemblyType
     {
         eStopDisassemblyTypeNever = 0,
         eStopDisassemblyTypeNoSource,
         eStopDisassemblyTypeAlways
     };
     
-    virtual Error
-    SetPropertyValue (const ExecutionContext *exe_ctx,
-                      VarSetOperationType op,
-                      const char *property_path,
-                      const char *value);
+    Error
+    SetPropertyValue(const ExecutionContext *exe_ctx,
+                     const char *value) override;
 
     bool
     GetAutoConfirm () const;
 
     const FormatEntity::Entry *
     GetDisassemblyFormat() const;
 
     const FormatEntity::Entry *

 
 private:
 
     // Use Debugger::CreateInstance() to get a shared pointer to a new
     // debugger object
     Debugger (lldb::LogOutputCallback m_log_callback, void *baton);
 
     DISALLOW_COPY_AND_ASSIGN (Debugger);
-    
 };
 
 } // namespace lldb_private
 
-#endif  // #if defined(__cplusplus)
-#endif  // liblldb_Debugger_h_
+#endif // liblldb_Debugger_h_

lldb/trunk/include/lldb/Core/Disassembler.h

~Instruction();
     }
     
     const char *
     GetMnemonic (const ExecutionContext* exe_ctx)
     {
         CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
         return m_opcode_name.c_str();
     }
+
     const char *
     GetOperands (const ExecutionContext* exe_ctx)
     {
         CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
         return m_mnemonics.c_str();
     }
     
     const char *
~Instruction();
     ///     Only needed if show_address is true.
     ///
     /// @param[in] max_address_text_size
     ///     The length of the longest address string at the start of the
     ///     disassembly line that will be printed (the Debugger::FormatDisassemblerAddress() string)
     ///     so this method can properly align the instruction opcodes.
     ///     May be 0 to indicate no indentation/alignment of the opcodes.
     //------------------------------------------------------------------
-
     virtual void
     Dump (Stream *s,
           uint32_t max_opcode_byte_size,
           bool show_address,
           bool show_bytes,
           const ExecutionContext* exe_ctx,
           const SymbolContext *sym_ctx,
           const SymbolContext *prev_sym_ctx,
CalculateMnemonicOperandsAndCommentIfNeeded (const ExecutionContext* exe_ctx)
         if (!m_calculated_strings)
         {
             m_calculated_strings = true;
             CalculateMnemonicOperandsAndComment(exe_ctx);
         }
     }
 };
 
-
 class InstructionList
 {
 public:
     InstructionList();
     ~InstructionList();
 
     size_t
     GetSize() const;

 
 class PseudoInstruction : 
     public Instruction
 {
 public:
 
     PseudoInstruction ();
     
-     virtual
-     ~PseudoInstruction ();
+    ~PseudoInstruction() override;
      
-    virtual bool
-    DoesBranch ();
+    bool
+    DoesBranch() override;
 
-    virtual bool
-    HasDelaySlot ();
+    bool
+    HasDelaySlot() override;
 
-    virtual void
-    CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx)
+    void
+    CalculateMnemonicOperandsAndComment(const ExecutionContext* exe_ctx) override
     {
         // TODO: fill this in and put opcode name into Instruction::m_opcode_name,
         // mnemonic into Instruction::m_mnemonics, and any comment into 
         // Instruction::m_comment
     }
     
-    virtual size_t
-    Decode (const Disassembler &disassembler,
-            const DataExtractor &data,
-            lldb::offset_t data_offset);
+    size_t
+    Decode(const Disassembler &disassembler,
+           lldb::offset_t data_offset) override;
             
     void
     SetOpcode (size_t opcode_size, void *opcode_data);
     
-    virtual void
-    SetDescription (const char *description);
+    void
+    SetDescription(const char *description) override;
     
 protected:
     std::string m_description;
     
     DISALLOW_COPY_AND_ASSIGN (PseudoInstruction);
 };
 
 class Disassembler :
Disassemble (Debugger &debugger,
                  uint32_t num_mixed_context_lines,
                  uint32_t options,
                  Stream &strm);
     
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     Disassembler(const ArchSpec &arch, const char *flavor);
-    virtual ~Disassembler();
+    ~Disassembler() override;
 
     typedef const char * (*SummaryCallback)(const Instruction& inst, ExecutionContext *exe_context, void *user_data);
 
     static bool 
     PrintInstructions (Disassembler *disasm_ptr,
                        Debugger &debugger,
                        const ArchSpec &arch,
                        const ExecutionContext &exe_ctx,
private:
     //------------------------------------------------------------------
     // For Disassembler only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (Disassembler);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Disassembler_h_
+#endif // liblldb_Disassembler_h_

lldb/trunk/include/lldb/Core/EmulateInstruction.h

 
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/Opcode.h"
 #include "lldb/Core/RegisterValue.h"
 
+namespace lldb_private {
+
 //----------------------------------------------------------------------
 /// @class EmulateInstruction EmulateInstruction.h "lldb/Core/EmulateInstruction.h"
 /// @brief A class that allows emulation of CPU opcodes.
 ///
 /// This class is a plug-in interface that is accessed through the 
 /// standard static FindPlugin function call in the EmulateInstruction
 /// class. The FindPlugin takes a target triple and returns a new object
 /// if there is a plug-in that supports the architecture and OS. Four

 /// then other threads could miss the breakpoint. 
 ///
 /// This class centralizes the code that usually is done in separate 
 /// code paths in a debugger (single step prediction, finding save
 /// restore locations of registers for unwinding stack frame variables)
 /// and emulating the instruction is just a bonus.
 //----------------------------------------------------------------------
 
-namespace lldb_private {
-
 class EmulateInstruction :
     public PluginInterface
 {
 public:
 
     static EmulateInstruction*
     FindPlugin (const ArchSpec &arch, 
                 InstructionType supported_inst_type,
struct Context
             
             struct ISAAndImmediateSigned 
             {
                 uint32_t isa;
                 int32_t signed_data32;      // signed immediate data
             } ISAAndImmediateSigned;
             
             uint32_t isa;
-                        
         } info;
         
         Context () :
             type (eContextInvalid),
             info_type (eInfoTypeNoArgs)
         {
         }
 
public:
     typedef bool   (*WriteRegisterCallback) (EmulateInstruction *instruction,
                                              void *baton,
                                              const Context &context, 
                                              const RegisterInfo *reg_info,
                                              const RegisterValue &reg_value);
 
     EmulateInstruction (const ArchSpec &arch);
 
-    virtual ~EmulateInstruction()
-    {
-    }
+    ~EmulateInstruction() override = default;
+
     //----------------------------------------------------------------------
     // Mandatory overrides
     //----------------------------------------------------------------------    
     virtual bool
     SupportsEmulatingInstructionsOfType (InstructionType inst_type) = 0;
     
     virtual bool
     SetTargetTriple (const ArchSpec &arch) = 0;
public:
     }
     
     const ArchSpec &
     GetArchitecture () const
     {
         return m_arch;
     }
 
-
     static size_t 
     ReadMemoryFrame (EmulateInstruction *instruction,
                      void *baton,
                      const Context &context, 
                      lldb::addr_t addr, 
                      void *dst,
                      size_t length);
     
protected:
     void *                  m_baton;
     ReadMemoryCallback      m_read_mem_callback;
     WriteMemoryCallback     m_write_mem_callback;
     ReadRegisterCallback    m_read_reg_callback;
     WriteRegisterCallback   m_write_reg_callback;
     lldb::addr_t            m_addr;
     Opcode                  m_opcode;
     
-
 private:
     //------------------------------------------------------------------
     // For EmulateInstruction only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (EmulateInstruction);
 };
 
-}   // namespace lldb_private
+} // namespace lldb_private
 
-#endif  // lldb_EmulateInstruction_h_
+#endif // lldb_EmulateInstruction_h_

lldb/trunk/include/lldb/Core/IOHandler.h

 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/Predicate.h"
 
 namespace curses
 {
     class Application;
     typedef std::unique_ptr<Application> ApplicationAP;
-}
+} // namespace curses
 
 namespace lldb_private {
 
     class IOHandler
     {
     public:
         enum class Type {
             CommandInterpreter,
protected:
         Type m_type;
         void *m_user_data;
         bool m_done;
         bool m_active;
 
     private:
         DISALLOW_COPY_AND_ASSIGN (IOHandler);
     };
     
-    
     //------------------------------------------------------------------
     /// A delegate class for use with IOHandler subclasses.
     ///
     /// The IOHandler delegate is designed to be mixed into classes so
     /// they can use an IOHandler subclass to fetch input and notify the
     /// object that inherits from this delegate class when a token is
     /// received.
     //------------------------------------------------------------------
     class IOHandlerDelegate
     {
     public:
         enum class Completion {
             None,
             LLDBCommand,
             Expression
         };
         
         IOHandlerDelegate (Completion completion = Completion::None) :
             m_completion(completion),
             m_io_handler_done (false)
         {
         }
         
         virtual
-        ~IOHandlerDelegate()
-        {
-        }
+        ~IOHandlerDelegate() = default;
         
         virtual void
         IOHandlerActivated (IOHandler &io_handler)
         {
         }
 
         virtual void
         IOHandlerDeactivated (IOHandler &io_handler)
public:
         // Return true if the interrupt was handled, false if the IOHandler
         // should continue to try handle the interrupt itself.
         //------------------------------------------------------------------
         virtual bool
         IOHandlerInterrupt (IOHandler &io_handler)
         {
             return false;
         }
+
     protected:
         Completion m_completion; // Support for common builtin completions
         bool m_io_handler_done;
     };
 
     //----------------------------------------------------------------------
     // IOHandlerDelegateMultiline
     //
     // A IOHandlerDelegate that handles terminating multi-line input when
     // the last line is equal to "end_line" which is specified in the
     // constructor.
     //----------------------------------------------------------------------
     class IOHandlerDelegateMultiline :
         public IOHandlerDelegate
     {
     public:
         IOHandlerDelegateMultiline (const char *end_line,
                                     Completion completion = Completion::None) :
             IOHandlerDelegate (completion),
             m_end_line((end_line && end_line[0]) ? end_line : "")
         {
         }
         
-        virtual
-        ~IOHandlerDelegateMultiline ()
-        {
-        }
+        ~IOHandlerDelegateMultiline() override = default;
         
         ConstString
         IOHandlerGetControlSequence (char ch) override
         {
             if (ch == 'd')
                 return ConstString (m_end_line + "\n");
             return ConstString();
         }
public:
                 // Remove the terminal line from "lines" so it doesn't appear in
                 // the resulting input and return true to indicate we are done
                 // getting lines
                 lines.PopBack();
                 return true;
             }
             return false;
         }
+
     protected:
         const std::string m_end_line;
     };
     
-    
     class IOHandlerEditline : public IOHandler
     {
     public:
         IOHandlerEditline (Debugger &debugger,
                            IOHandler::Type type,
                            const char *editline_name, // Used for saving history files
                            const char *prompt,
                            const char *continuation_prompt,
public:
                            const char *editline_name, // Used for saving history files
                            const char *prompt,
                            const char *continuation_prompt,
                            bool multi_line,
                            bool color_prompts,
                            uint32_t line_number_start, // If non-zero show line numbers starting at 'line_number_start'
                            IOHandlerDelegate &delegate);
         
-        virtual
-        ~IOHandlerEditline ();
+        ~IOHandlerEditline() override;
         
         void
         Run () override;
         
         void
         Cancel () override;
 
         bool
class IOHandlerConfirm :
         public IOHandlerDelegate,
         public IOHandlerEditline
     {
     public:
         IOHandlerConfirm (Debugger &debugger,
                           const char *prompt,
                           bool default_response);
         
-        virtual
-        ~IOHandlerConfirm ();
+        ~IOHandlerConfirm() override;
                 
         bool
         GetResponse () const
         {
             return m_user_response;
         }
         
         int
#endif
     };
 
     class IOHandlerCursesValueObjectList :
         public IOHandler
     {
     public:
         IOHandlerCursesValueObjectList (Debugger &debugger, ValueObjectList &valobj_list);
         
-        virtual
-        ~IOHandlerCursesValueObjectList ();
+        ~IOHandlerCursesValueObjectList() override;
         
         void
         Run () override;
         
         void
         GotEOF() override;
+
     protected:
         ValueObjectList m_valobj_list;
     };
 
     class IOHandlerStack
     {
     public:
         
         IOHandlerStack () :
             m_stack(),
             m_mutex(Mutex::eMutexTypeRecursive),
             m_top (NULL)
         {
         }
         
-        ~IOHandlerStack ()
-        {
-        }
+        ~IOHandlerStack() = default;
         
         size_t
         GetSize () const
         {
             Mutex::Locker locker (m_mutex);
             return m_stack.size();
         }
         
public:
                 return m_top->GetHelpPrologue();
             return NULL;
         }
 
         void
         PrintAsync (Stream *stream, const char *s, size_t len);
 
     protected:
-        
         typedef std::vector<lldb::IOHandlerSP> collection;
         collection m_stack;
         mutable Mutex m_mutex;
         IOHandler *m_top;
         
     private:
-        
         DISALLOW_COPY_AND_ASSIGN (IOHandlerStack);
     };
 
 } // namespace lldb_private
 
-#endif // #ifndef liblldb_IOHandler_h_
+#endif // liblldb_IOHandler_h_

lldb/trunk/include/lldb/Core/Log.h

protected:
     lldb::StreamSP m_stream_sp;
     Flags m_options;
     Flags m_mask_bits;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(Log);
 };
 
-
 class LogChannel : public PluginInterface
 {
 public:
   LogChannel();
 
-  virtual ~LogChannel();
+  ~LogChannel() override;
 
   static lldb::LogChannelSP FindPlugin(const char *plugin_name);
 
     // categories is an array of chars that ends with a NULL element.
   virtual void Disable(const char **categories, Stream *feedback_strm) = 0;
 
   virtual bool Enable(
       lldb::StreamSP &log_stream_sp, uint32_t log_options,
       Stream *feedback_strm,        // Feedback stream for argument errors etc
       const char **categories) = 0; // The categories to enable within this logging stream, if empty, enable default set
 
   virtual void ListCategories(Stream *strm) = 0;
 
 protected:
     std::unique_ptr<Log> m_log_ap;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(LogChannel);
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_Log_H_
+#endif // liblldb_Log_h_

lldb/trunk/include/lldb/Core/Module.h

 //===-- Module.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_Module_h_
 #define liblldb_Module_h_
 
 #include <atomic>
+
 #include "lldb/lldb-forward.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
// ModuleList). If this is the case we need to know about it.
     Module (const ModuleSpec &module_spec);
     
     static lldb::ModuleSP
     CreateJITModule (const lldb::ObjectFileJITDelegateSP &delegate_sp);
     
     //------------------------------------------------------------------
     /// Destructor.
     //------------------------------------------------------------------
-    virtual 
-    ~Module ();
+    ~Module() override;
 
     bool
     MatchesModuleSpec (const ModuleSpec &module_ref);
     
     //------------------------------------------------------------------
     /// Set the load address for all sections in a module to be the
     /// file address plus \a slide.
     ///
SetLoadAddress (Target &target,
                     bool value_is_offset,
                     bool &changed);
     
     //------------------------------------------------------------------
     /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
     ///
     /// @see SymbolContextScope
     //------------------------------------------------------------------
-    virtual void
-    CalculateSymbolContext (SymbolContext* sc);
+    void
+    CalculateSymbolContext(SymbolContext* sc) override;
 
-    virtual lldb::ModuleSP
-    CalculateSymbolContextModule ();
+    lldb::ModuleSP
+    CalculateSymbolContextModule() override;
 
     void
     GetDescription (Stream *s,
                     lldb::DescriptionLevel level = lldb::eDescriptionLevelFull);
 
     //------------------------------------------------------------------
     /// Get the module path and object name.
     ///
// ModuleList). If this is the case we need to know about it.
     void
     Dump (Stream *s);
 
     //------------------------------------------------------------------
     /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
     ///
     /// @see SymbolContextScope
     //------------------------------------------------------------------
-    virtual void
-    DumpSymbolContext (Stream *s);
-
-    
+    void
+    DumpSymbolContext(Stream *s) override;
     //------------------------------------------------------------------
     /// Find a symbol in the object file's symbol table.
     ///
     /// @param[in] name
     ///     The name of the symbol that we are looking for.
     ///
     /// @param[in] symbol_type
     ///     If set to eSymbolTypeAny, find a symbol of any type that
// ModuleList). If this is the case we need to know about it.
     ///
     /// @return
     ///     The number of matches added to \a sc_list.
     //------------------------------------------------------------------
     size_t
     FindCompileUnits (const FileSpec &path,
                       bool append,
                       SymbolContextList &sc_list);
-    
-
     //------------------------------------------------------------------
     /// Find functions by name.
     ///
     /// If the function is an inlined function, it will have a block,
     /// representing the inlined function, and the function will be the
     /// containing function.  If it is not inlined, then the block will 
     /// be NULL.
     ///
// ModuleList). If this is the case we need to know about it.
     ///     A integer that contains SymbolContext::Scope bits set for
     ///     each item that was successfully resolved.
     ///
     /// @see SymbolContext::Scope
     //------------------------------------------------------------------
     uint32_t
     ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
 
-
     void
     SetFileSpecAndObjectName (const FileSpec &file,
                               const ConstString &object_name);
 
     bool
     GetIsDynamicLinkEditor ();
 
     TypeSystem *
// ModuleList). If this is the case we need to know about it.
     ///
     /// @return
     ///     /b true if \a path was successfully located and \a new_path
     ///     is filled in with a new source path, \b false otherwise.
     //------------------------------------------------------------------
     bool
     RemapSourceFile (const char *path, std::string &new_path) const;
     
-    
     //------------------------------------------------------------------
     /// Prepare to do a function name lookup.
     ///
     /// Looking up functions by name can be a tricky thing. LLDB requires
     /// that accelerator tables contain full names for functions as well
     /// as function basenames which include functions, class methods and
     /// class functions. When the user requests that an action use a
     /// function by name, we are sometimes asked to automatically figure
protected:
     SectionList *
     GetUnifiedSectionList();
 
     friend class ModuleList;
     friend class ObjectFile;
     friend class SymbolFile;
 
 private:
-    
     Module (); // Only used internally by CreateJITModule ()
     
     size_t
     FindTypes_Impl (const SymbolContext& sc, 
                     const ConstString &name,
                     const CompilerDeclContext *parent_decl_ctx,
                     bool append, 
                     size_t max_matches,
                     TypeMap& types);
 
-    
     DISALLOW_COPY_AND_ASSIGN (Module);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Module_h_
+#endif // liblldb_Module_h_

lldb/trunk/include/lldb/Core/SearchFilter.h

 /// @class SearchFilterForUnconstrainedSearches SearchFilter.h "lldb/Core/SearchFilter.h"
 /// @brief This is a SearchFilter that searches through all modules.  It also consults the Target::ModuleIsExcludedForUnconstrainedSearches.
 //----------------------------------------------------------------------
 class SearchFilterForUnconstrainedSearches :
     public SearchFilter
 {
 public:
     SearchFilterForUnconstrainedSearches (const lldb::TargetSP &target_sp) : SearchFilter(target_sp) {}
-    ~SearchFilterForUnconstrainedSearches () {}
+    ~SearchFilterForUnconstrainedSearches() override = default;
     
     bool 
     ModulePasses (const FileSpec &module_spec) override;
     
     bool
     ModulePasses (const lldb::ModuleSP &module_sp) override;
 
 protected:
     lldb::SearchFilterSP
     DoCopyForBreakpoint (Breakpoint &breakpoint) override;
-
 };
 
 //----------------------------------------------------------------------
 /// @class SearchFilterByModule SearchFilter.h "lldb/Core/SearchFilter.h"
 /// @brief This is a SearchFilter that restricts the search to a given module.
 //----------------------------------------------------------------------
 
 class SearchFilterByModule :
public:
     /// @param[in] module
     ///    The Module that limits the search.
     //------------------------------------------------------------------
     SearchFilterByModule (const lldb::TargetSP &targetSP,
                           const FileSpec &module);
 
     SearchFilterByModule (const SearchFilterByModule& rhs);
 
-    virtual
-    ~SearchFilterByModule ();
+    ~SearchFilterByModule() override;
 
     const SearchFilterByModule&
     operator=(const SearchFilterByModule& rhs);
 
     bool
     ModulePasses (const lldb::ModuleSP &module_sp) override;
 
     bool
public:
     /// @param[in] module
     ///    The Module that limits the search.
     //------------------------------------------------------------------
     SearchFilterByModuleList (const lldb::TargetSP &targetSP,
                               const FileSpecList &module_list);
 
     SearchFilterByModuleList (const SearchFilterByModuleList& rhs);
 
-    virtual
-    ~SearchFilterByModuleList ();
+    ~SearchFilterByModuleList() override;
 
     const SearchFilterByModuleList&
     operator=(const SearchFilterByModuleList& rhs);
 
     bool
     ModulePasses (const lldb::ModuleSP &module_sp) override;
 
     bool
public:
     ///    The Module that limits the search.
     //------------------------------------------------------------------
     SearchFilterByModuleListAndCU (const lldb::TargetSP &targetSP,
                                    const FileSpecList &module_list,
                                    const FileSpecList &cu_list);
 
     SearchFilterByModuleListAndCU (const SearchFilterByModuleListAndCU& rhs);
 
-    virtual
-    ~SearchFilterByModuleListAndCU ();
+    ~SearchFilterByModuleListAndCU() override;
 
     const SearchFilterByModuleListAndCU&
     operator=(const SearchFilterByModuleListAndCU& rhs);
 
     bool
     AddressPasses (Address &address) override;
 
     bool

 
 private:
     FileSpecList m_module_spec_list;
     FileSpecList m_cu_spec_list;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_SearchFilter_h_
+#endif // liblldb_SearchFilter_h_

lldb/trunk/include/lldb/Core/StreamGDBRemote.h

namespace lldb_private {
     {
         public:
         StreamGDBRemote ();
         
         StreamGDBRemote (uint32_t flags,
                          uint32_t addr_size,
                          lldb::ByteOrder byte_order);
         
-        virtual
-        ~StreamGDBRemote ();
+        ~StreamGDBRemote() override;
         
         //------------------------------------------------------------------
         /// Output a block of data to the stream performing GDB-remote escaping.
         ///
         /// @param[in] s
         ///     A block of data.
         ///
         /// @param[in] src_len
         ///     The amount of data to write.
         ///
         /// @return
         ///     Number of bytes written.
         //------------------------------------------------------------------
         int
         PutEscapedBytes (const void* s,
                          size_t src_len);
     };
 
 } // namespace lldb_private
 
-#endif  // liblldb_StreamGDBRemote_h_
+#endif // liblldb_StreamGDBRemote_h_

lldb/trunk/include/lldb/Core/ValueObjectChild.h

 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // A child of another ValueObject.
 //----------------------------------------------------------------------
 class ValueObjectChild : public ValueObject
 {
 public:
-    virtual ~ValueObjectChild();
+    ~ValueObjectChild() override;
 
-    virtual uint64_t
-    GetByteSize()
+    uint64_t
+    GetByteSize() override
     {
         return m_byte_size;
     }
 
-    virtual lldb::offset_t
-    GetByteOffset()
+    lldb::offset_t
+    GetByteOffset() override
     {
         return m_byte_offset;
     }
 
-    virtual uint32_t
-    GetBitfieldBitSize()
+    uint32_t
+    GetBitfieldBitSize() override
     {
         return m_bitfield_bit_size;
     }
 
-    virtual uint32_t
-    GetBitfieldBitOffset()
+    uint32_t
+    GetBitfieldBitOffset() override
     {
         return m_bitfield_bit_offset;
     }
 
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
 
-    virtual ConstString
-    GetQualifiedTypeName();
+    ConstString
+    GetQualifiedTypeName() override;
     
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() override;
     
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
 
-    virtual bool
-    IsBaseClass ()
+    bool
+    IsBaseClass() override
     {
         return m_is_base_class;
     }
 
-    virtual bool
-    IsDereferenceOfParent ()
+    bool
+    IsDereferenceOfParent() override
     {
         return m_is_deref_of_parent;
     }
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual LazyBool
-    CanUpdateWithInvalidExecutionContext ();
+    LazyBool
+    CanUpdateWithInvalidExecutionContext() override;
 
-    virtual CompilerType
-    GetCompilerTypeImpl ()
+    CompilerType
+    GetCompilerTypeImpl() override
     {
         return m_compiler_type;
     }
     
     CompilerType m_compiler_type;
     ConstString m_type_name;
     uint64_t m_byte_size;
     int32_t m_byte_offset;
     uint8_t m_bitfield_bit_size;
     uint8_t m_bitfield_bit_offset;
     bool m_is_base_class;
     bool m_is_deref_of_parent;
     llvm::Optional<LazyBool> m_can_update_with_invalid_exe_ctx;
 
 //
 //  void
 //  ReadValueFromMemory (ValueObject* parent, lldb::addr_t address);
 
 protected:
     friend class ValueObject;
     friend class ValueObjectConstResult;
     friend class ValueObjectConstResultImpl;
+
     ValueObjectChild (ValueObject &parent,
                       const CompilerType &compiler_type,
                       const ConstString &name,
                       uint64_t byte_size,
                       int32_t byte_offset,
                       uint32_t bitfield_bit_size,
                       uint32_t bitfield_bit_offset,
                       bool is_base_class,

lldb/trunk/include/lldb/Core/ValueObjectConstResult.h

 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // A frozen ValueObject copied into host memory
 //----------------------------------------------------------------------
 class ValueObjectConstResult : public ValueObject
 {
 public:
+    ~ValueObjectConstResult() override;
+
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope,
             lldb::ByteOrder byte_order, 
             uint32_t addr_byte_size,
             lldb::addr_t address = LLDB_INVALID_ADDRESS);
 
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope,
Create (ExecutionContextScope *exe_scope,
             const ConstString &name,
             Module* module = nullptr);
 
     // When an expression fails to evaluate, we return an error
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope,
             const Error& error);
 
-    virtual ~ValueObjectConstResult();
-
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
 
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
 
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() override;
     
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
 
     void
     SetByteSize (size_t size);
     
-    virtual lldb::ValueObjectSP
-    Dereference (Error &error);
+    lldb::ValueObjectSP
+    Dereference(Error &error) 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
-    GetSyntheticChildAtOffset(uint32_t offset, const CompilerType& type, bool can_create);
+    lldb::ValueObjectSP
+    GetSyntheticChildAtOffset(uint32_t offset, const CompilerType& type, bool can_create) override;
     
-    virtual lldb::ValueObjectSP
-    AddressOf (Error &error);
+    lldb::ValueObjectSP
+    AddressOf(Error &error) override;
     
-    virtual lldb::addr_t
-    GetAddressOf (bool scalar_is_load_address = true,
-                  AddressType *address_type = NULL);
+    lldb::addr_t
+    GetAddressOf(bool scalar_is_load_address = true,
+                 AddressType *address_type = NULL) override;
     
-    virtual size_t
-    GetPointeeData (DataExtractor& data,
-                    uint32_t item_idx = 0,
-          uint32_t item_count = 1);
+    size_t
+    GetPointeeData(DataExtractor& data,
+                   uint32_t item_count = 1) override;
     
-    virtual lldb::addr_t
-    GetLiveAddress()
+    lldb::addr_t
+    GetLiveAddress() override
     {
         return m_impl.GetLiveAddress();
     }
     
-    virtual void
+    void
     SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
-                   AddressType address_type = eAddressTypeLoad)
+                   AddressType address_type = eAddressTypeLoad) override
     {
-        m_impl.SetLiveAddress(addr,
-                              address_type);
+        m_impl.SetLiveAddress(addr, address_type);
     }
     
-    virtual lldb::ValueObjectSP
-    GetDynamicValue (lldb::DynamicValueType valueType);
+    lldb::ValueObjectSP
+    GetDynamicValue(lldb::DynamicValueType valueType) override;
     
-    virtual lldb::LanguageType
-    GetPreferredDisplayLanguage ();
+    lldb::LanguageType
+    GetPreferredDisplayLanguage() override;
 
-    virtual lldb::ValueObjectSP
-    Cast (const CompilerType &compiler_type);
+    lldb::ValueObjectSP
+    Cast(const CompilerType &compiler_type) override;
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     ConstString m_type_name;
     uint64_t m_byte_size;
     
     ValueObjectConstResultImpl m_impl;
 
 private:
     friend class ValueObjectConstResultImpl;
+
     ValueObjectConstResult (ExecutionContextScope *exe_scope,
                             lldb::ByteOrder byte_order, 
                             uint32_t addr_byte_size,
                             lldb::addr_t address);
 
     ValueObjectConstResult (ExecutionContextScope *exe_scope,
                             const CompilerType &compiler_type,
                             const ConstString &name,

lldb/trunk/include/lldb/Core/ValueObjectDynamicValue.h

 
 //----------------------------------------------------------------------
 // A ValueObject that represents memory at a given address, viewed as some 
 // set lldb type.
 //----------------------------------------------------------------------
 class ValueObjectDynamicValue : public ValueObject
 {
 public:
-    virtual
-    ~ValueObjectDynamicValue();
+    ~ValueObjectDynamicValue() 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 size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
 
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
     
-    virtual bool
-    IsDynamic ()
+    bool
+    IsDynamic() override
     {
         return true;
     }
     
-    virtual bool
-    GetIsConstant () const
+    bool
+    GetIsConstant() const override
     {
         return false;
     }
     
-    virtual ValueObject *
-    GetParent()
+    ValueObject *
+    GetParent() override
     {
         if (m_parent)
             return m_parent->GetParent();
         else
             return NULL;
     }
 
-    virtual const ValueObject *
-    GetParent() const
+    const ValueObject *
+    GetParent() const override
     {
         if (m_parent)
             return m_parent->GetParent();
         else
             return NULL;
     }
 
-    virtual lldb::ValueObjectSP
-    GetStaticValue ()
+    lldb::ValueObjectSP
+    GetStaticValue() override
     {
         return m_parent->GetSP();
     }
 
     void
     SetOwningSP (lldb::ValueObjectSP &owning_sp)
     {
         if (m_owning_valobj_sp == owning_sp)
             return;
             
         assert (m_owning_valobj_sp.get() == NULL);
         m_owning_valobj_sp = owning_sp;
     }
     
-    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 TypeImpl
-    GetTypeImpl ();
+    TypeImpl
+    GetTypeImpl() override;
     
-    virtual lldb::LanguageType
-    GetPreferredDisplayLanguage ();
+    lldb::LanguageType
+    GetPreferredDisplayLanguage() override;
     
     void
     SetPreferredDisplayLanguage (lldb::LanguageType);
     
-    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 lldb::DynamicValueType
-    GetDynamicValueTypeImpl ()
+    lldb::DynamicValueType
+    GetDynamicValueTypeImpl() override
     {
         return m_use_dynamic;
     }
     
-    virtual bool
-    HasDynamicValueTypeInfo ()
+    bool
+    HasDynamicValueTypeInfo() override
     {
         return true;
     }
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     Address  m_address;  ///< The variable that this value object is based upon
     TypeAndOrName m_dynamic_type_info; // We can have a type_sp or just a name
     lldb::ValueObjectSP m_owning_valobj_sp;
     lldb::DynamicValueType m_use_dynamic;
     TypeImpl m_type_impl;
 
 private:
     friend class ValueObject;
     friend class ValueObjectConstResult;
     ValueObjectDynamicValue (ValueObject &parent, lldb::DynamicValueType use_dynamic);
 
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectDynamicValue);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectDynamicValue_h_
+#endif // liblldb_ValueObjectDynamicValue_h_

lldb/trunk/include/lldb/Core/ValueObjectMemory.h

 
 //----------------------------------------------------------------------
 // A ValueObject that represents memory at a given address, viewed as some 
 // set lldb type.
 //----------------------------------------------------------------------
 class ValueObjectMemory : public ValueObject
 {
 public:
+    ~ValueObjectMemory() override;
+
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, 
             const char *name,
             const Address &address, 
             lldb::TypeSP &type_sp);
 
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, 
             const char *name,
             const Address &address, 
             const CompilerType &ast_type);
 
-    virtual
-    ~ValueObjectMemory();
-
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
 
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() override;
     
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
 
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
 
-    virtual lldb::ModuleSP
-    GetModule();
+    lldb::ModuleSP
+    GetModule() override;
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     Address  m_address;  ///< The variable that this value object is based upon
     lldb::TypeSP m_type_sp;
     CompilerType m_compiler_type;
 
 private:
     ValueObjectMemory (ExecutionContextScope *exe_scope, 
                        const char *name,
                        const Address &address, 
                        lldb::TypeSP &type_sp);
 
     ValueObjectMemory (ExecutionContextScope *exe_scope,
                        const char *name, 
                        const Address &address,
                        const CompilerType &ast_type);
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectMemory);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectMemory_h_
+#endif // liblldb_ValueObjectMemory_h_

lldb/trunk/include/lldb/Core/ValueObjectRegister.h

 
 //----------------------------------------------------------------------
 // A ValueObject that contains a root variable that may or may not
 // have children.
 //----------------------------------------------------------------------
 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;
 
 private:
     ValueObjectRegisterContext (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp);
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectRegisterContext);
 };
 
 class ValueObjectRegisterSet : public ValueObject
 {
 public:
+    ~ValueObjectRegisterSet() override;
+
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t set_idx);
 
-    virtual
-    ~ValueObjectRegisterSet();
-
-    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);
-
-    virtual size_t
-    GetIndexOfChildWithName (const ConstString &name);
+    lldb::ValueObjectSP
+    GetChildMemberWithName(const ConstString &name, bool can_create) override;
 
+    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;
     uint32_t m_reg_set_idx;
 
 private:
     friend class ValueObjectRegisterContext;
+
     ValueObjectRegisterSet (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t set_idx);
 
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectRegisterSet);
 };
 
 class ValueObjectRegister : public ValueObject
 {
 public:
+    ~ValueObjectRegister() override;
+
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
 
-    virtual
-    ~ValueObjectRegister();
-
-    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;
     RegisterValue m_reg_value;
     ConstString m_type_name;
     CompilerType m_compiler_type;
 
 private:
     void
     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);
 
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectRegister);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectRegister_h_
+#endif // liblldb_ValueObjectRegister_h_