[LLDB] Fix Clang-tidy misc-use-override warnings in include/lldb/Utility and some files in include/lldb/Target, 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.

[labath]

Comitted as r245277.

lldb/trunk/include/lldb/Target/ABI.h

struct CallArgument
         };
         eType  type;                /* value of eType */
         size_t size;                /* size in bytes of this argument */
 
         lldb::addr_t  value;                    /* literal value */
         std::unique_ptr<uint8_t[]> data_ap;     /* host data pointer */
     };
 
-    virtual
-    ~ABI();
+    ~ABI() override;
 
     virtual size_t
     GetRedZoneSize () const = 0;
     
     virtual bool
     PrepareTrivialCall ( lldb_private::Thread &thread, 
                          lldb::addr_t sp,
                          lldb::addr_t functionAddress,
public:
     GetRegisterInfoByKind (lldb::RegisterKind reg_kind, 
                            uint32_t reg_num, 
                            RegisterInfo &info);
 
     static lldb::ABISP
     FindPlugin (const ArchSpec &arch);
     
 protected:
+
     //------------------------------------------------------------------
     // Classes that inherit from ABI can see and modify these
     //------------------------------------------------------------------
     ABI();
+
 private:
+
     DISALLOW_COPY_AND_ASSIGN (ABI);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ABI_h_
+#endif // liblldb_ABI_h_

lldb/trunk/include/lldb/Target/CPPLanguageRuntime.h

protected:
         llvm::StringRef m_context;      // Decl context: "lldb::SBTarget"
         llvm::StringRef m_arguments;    // Arguments:    "(unsigned int)"
         llvm::StringRef m_qualifiers;   // Qualifiers:   "const"
         Type m_type;
         bool m_parsed;
         bool m_parse_error;
     };
 
-    virtual
-    ~CPPLanguageRuntime();
+    ~CPPLanguageRuntime() override;
     
-    virtual lldb::LanguageType
-    GetLanguageType () const
+    lldb::LanguageType
+    GetLanguageType() const override
     {
         return lldb::eLanguageTypeC_plus_plus;
     }
     
     virtual bool
     IsVTableName (const char *name) = 0;
     
-    virtual bool
-    GetObjectDescription (Stream &str, ValueObject &object);
+    bool
+    GetObjectDescription(Stream &str, ValueObject &object) override;
     
-    virtual bool
-    GetObjectDescription (Stream &str, Value &value, ExecutionContextScope *exe_scope);
+    bool
+    GetObjectDescription(Stream &str, Value &value, ExecutionContextScope *exe_scope) override;
     
     static bool
     IsCPPMangledName(const char *name);
 
     // Extract C++ context and identifier from a string using heuristic matching (as opposed to
     // CPPLanguageRuntime::MethodName which has to have a fully qualified C++ name with parens and arguments.
     // If the name is a lone C identifier (e.g. C) or a qualified C identifier (e.g. A::B::C) it will return true,
     // and identifier will be the identifier (C and C respectively) and the context will be "" and "A::B::" respectively.
public:
     // to ObjC or other languages if necessary
     static uint32_t
     FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents);
 
     virtual size_t
     GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) = 0;
 
 protected:
+
     //------------------------------------------------------------------
     // Classes that inherit from CPPLanguageRuntime can see and modify these
     //------------------------------------------------------------------
     CPPLanguageRuntime(Process *process);
+
 private:
+
     DISALLOW_COPY_AND_ASSIGN (CPPLanguageRuntime);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CPPLanguageRuntime_h_
+#endif // liblldb_CPPLanguageRuntime_h_

lldb/trunk/include/lldb/Target/DynamicLoader.h

public:
     DynamicLoader (Process *process);
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual since this class is designed to be
     /// inherited from by the plug-in instance.
     //------------------------------------------------------------------
-    virtual
-    ~DynamicLoader ();
+    ~DynamicLoader() override;
 
     //------------------------------------------------------------------
     /// Called after attaching a process.
     ///
     /// Allow DynamicLoader plug-ins to execute some code after
     /// attaching to a process.
     //------------------------------------------------------------------
     virtual void
protected:
     // Return LLDB_INVALID_ADDRESS if the read fails.
     lldb::addr_t
     ReadPointer(lldb::addr_t addr);
 
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     Process* m_process; ///< The process that this dynamic loader plug-in is tracking.
+
 private:
-    DISALLOW_COPY_AND_ASSIGN (DynamicLoader);
 
+    DISALLOW_COPY_AND_ASSIGN (DynamicLoader);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_DynamicLoader_h_
+#endif // liblldb_DynamicLoader_h_

lldb/trunk/include/lldb/Target/LanguageRuntime.h

 #include "lldb/Target/ExecutionContextScope.h"
 
 namespace lldb_private {
 
 class LanguageRuntime :
     public PluginInterface
 {
 public:
-    virtual
-    ~LanguageRuntime();
+
+    ~LanguageRuntime() override;
     
     static LanguageRuntime* 
     FindPlugin (Process *process, lldb::LanguageType language);
 
     static void
     InitializeCommands (CommandObject* parent);
     
     virtual lldb::LanguageType
public:
     IsRuntimeSupportValue (ValueObject& valobj)
     {
         return false;
     }
 
     virtual void
     ModulesDidLoad (const ModuleList &module_list)
     {
-        return;
     }
 
 protected:
     //------------------------------------------------------------------
     // Classes that inherit from LanguageRuntime can see and modify these
     //------------------------------------------------------------------
     
     LanguageRuntime(Process *process);
     Process *m_process;
 private:
+
     DISALLOW_COPY_AND_ASSIGN (LanguageRuntime);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_LanguageRuntime_h_
+#endif // liblldb_LanguageRuntime_h_

lldb/trunk/include/lldb/Target/OperatingSystem.h

 /// OS objects, like threads, during the lifetime of a debug session. 
 /// This is commonly used when attaching to an operating system that is
 /// halted, such as when debugging over JTAG or connecting to low level
 /// kernel debug services.
 //----------------------------------------------------------------------
 
 class OperatingSystem :
     public PluginInterface
-
 {
 public:
     //------------------------------------------------------------------
     /// Find a halted OS plugin for a given process.
     ///
     /// Scans the installed OperatingSystem plug-ins and tries to find
     /// an instance that matches the current target triple and 
     /// executable.
public:
     static OperatingSystem*
     FindPlugin (Process *process, const char *plugin_name);
 
     //------------------------------------------------------------------
     // Class Methods
     //------------------------------------------------------------------
     OperatingSystem (Process *process);
     
-    virtual 
-    ~OperatingSystem();
+    ~OperatingSystem() override;
     
     //------------------------------------------------------------------
     // Plug-in Methods
     //------------------------------------------------------------------
     virtual bool
     UpdateThreadList (ThreadList &old_thread_list,
                       ThreadList &real_thread_list,
                       ThreadList &new_thread_list) = 0;
protected:
     //------------------------------------------------------------------
     Process* m_process; ///< The process that this dynamic loader plug-in is tracking.
 private:
     DISALLOW_COPY_AND_ASSIGN (OperatingSystem);
 };
 
 } // namespace lldb_private
 
-#endif // #ifndef liblldb_OperatingSystem_h_
+#endif // liblldb_OperatingSystem_h_

lldb/trunk/include/lldb/Target/Platform.h

public:
         Platform (bool is_host_platform);
 
         //------------------------------------------------------------------
         /// Destructor.
         ///
         /// The destructor is virtual since this class is designed to be
         /// inherited from by the plug-in instance.
         //------------------------------------------------------------------
-        virtual
-        ~Platform();
+        ~Platform() override;
 
         //------------------------------------------------------------------
         /// Find a platform plugin for a given process.
         ///
         /// Scans the installed Platform plug-ins and tries to find
         /// an instance that can be used for \a process
         ///
         /// @param[in] process
private:
         DISALLOW_COPY_AND_ASSIGN (PlatformList);
     };
     
     class OptionGroupPlatformRSync : public lldb_private::OptionGroup
     {
     public:
         OptionGroupPlatformRSync ();
         
-        virtual
-        ~OptionGroupPlatformRSync ();
+        ~OptionGroupPlatformRSync() override;
         
-        virtual lldb_private::Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        lldb_private::Error
+        SetOptionValue(CommandInterpreter &interpreter,
+           uint32_t option_idx,
+           const char *option_value) override;
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         const lldb_private::OptionDefinition*
-        GetDefinitions ();
+        GetDefinitions() override;
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        uint32_t
+        GetNumDefinitions() override;
         
         // Options table: Required for subclasses of Options.
         
         static lldb_private::OptionDefinition g_option_table[];
         
         // Instance variables to hold the values for command options.
         
         bool m_rsync;
         std::string m_rsync_opts;
         std::string m_rsync_prefix;
         bool m_ignores_remote_hostname;
     private:
         DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformRSync);
     };
     
     class OptionGroupPlatformSSH : public lldb_private::OptionGroup
     {
     public:
         OptionGroupPlatformSSH ();
         
-        virtual
-        ~OptionGroupPlatformSSH ();
+        ~OptionGroupPlatformSSH() override;
         
-        virtual lldb_private::Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        lldb_private::Error
+        SetOptionValue(CommandInterpreter &interpreter,
+           uint32_t option_idx,
+           const char *option_value) override;
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        uint32_t
+        GetNumDefinitions() override;
         
         const lldb_private::OptionDefinition*
-        GetDefinitions ();
+        GetDefinitions() override;
         
         // Options table: Required for subclasses of Options.
         
         static lldb_private::OptionDefinition g_option_table[];
         
         // Instance variables to hold the values for command options.
         
         bool m_ssh;
         std::string m_ssh_opts;
 
     private:
 
         DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformSSH);
     };
     
     class OptionGroupPlatformCaching : public lldb_private::OptionGroup
     {
     public:
         OptionGroupPlatformCaching ();
         
-        virtual
-        ~OptionGroupPlatformCaching ();
+        ~OptionGroupPlatformCaching() override;
         
-        virtual lldb_private::Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        lldb_private::Error
+        SetOptionValue(CommandInterpreter &interpreter,
+           uint32_t option_idx,
+           const char *option_value) override;
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        uint32_t
+        GetNumDefinitions() override;
         
         const lldb_private::OptionDefinition*
-        GetDefinitions ();
+        GetDefinitions() override;
         
         // Options table: Required for subclasses of Options.
         
         static lldb_private::OptionDefinition g_option_table[];
         
         // Instance variables to hold the values for command options.
         
         std::string m_cache_dir;
     private:
         DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformCaching);
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_Platform_h_
+#endif // liblldb_Platform_h_

lldb/trunk/include/lldb/Target/Process.h

 // ProcessProperties
 //----------------------------------------------------------------------
 class ProcessProperties : public Properties
 {
 public:
     // Pass NULL for "process" if the ProcessProperties are to be the global copy
     ProcessProperties (lldb_private::Process *process);
 
-    virtual
-    ~ProcessProperties();
+    ~ProcessProperties() override;
     
     bool
     GetDisableMemoryCache() const;
 
     uint64_t
     GetMemoryCacheLineSize () const;
 
     Args
public:
     
     ProcessLaunchCommandOptions (CommandInterpreter &interpreter) :
         Options(interpreter)
     {
         // Keep default values of all options in one place: OptionParsingStarting ()
         OptionParsingStarting ();
     }
     
-    ~ProcessLaunchCommandOptions ()
+    ~ProcessLaunchCommandOptions() override
     {
     }
     
     Error
-    SetOptionValue (uint32_t option_idx, const char *option_arg);
+    SetOptionValue (uint32_t option_idx, const char *option_arg) override;
     
     void
-    OptionParsingStarting ()
+    OptionParsingStarting() override
     {
         launch_info.Clear();
         disable_aslr = eLazyBoolCalculate;
     }
     
     const OptionDefinition*
-    GetDefinitions ()
+    GetDefinitions() override
     {
         return g_option_table;
     }
     
     // Options table: Required for subclasses of Options.
     
     static OptionDefinition g_option_table[];
     
public:
     // try to lock it to see if they can immediately access the stopped
     // process. If the try read lock fails, then the process is running.
     typedef ProcessRunLock::ProcessRunLocker StopLocker;
 
     // These two functions fill out the Broadcaster interface:
     
     static ConstString &GetStaticBroadcasterClass ();
 
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }
 
     
     //------------------------------------------------------------------
     /// A notification structure that can be used by clients to listen
     /// for changes in a process's lifetime.
class ProcessEventData :
         public EventData
     {
         friend class Process;
         
         public:
             ProcessEventData ();
             ProcessEventData (const lldb::ProcessSP &process, lldb::StateType state);
 
-            virtual ~ProcessEventData();
+            ~ProcessEventData() override;
 
             static const ConstString &
             GetFlavorString ();
 
-            virtual const ConstString &
-            GetFlavor () const;
+            const ConstString &
+            GetFlavor() const override;
 
             lldb::ProcessSP
             GetProcessSP() const
             {
                 return m_process_wp.lock();
             }
 
             lldb::StateType
class ProcessEventData :
             }
         
             bool
             GetInterrupted () const
             {
                 return m_interrupted;
             }
 
-            virtual void
-            Dump (Stream *s) const;
+            void
+            Dump(Stream *s) const override;
 
-            virtual void
-            DoOnRemoval (Event *event_ptr);
+            void
+            DoOnRemoval(Event *event_ptr) override;
 
             static const Process::ProcessEventData *
             GetEventDataFromEvent (const Event *event_ptr);
 
             static lldb::ProcessSP
             GetProcessFromEvent (const Event *event_ptr);
 
             static lldb::StateType
#endif
     Process(Target &target, Listener &listener, const lldb::UnixSignalsSP &unix_signals_sp);
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual since this class is designed to be
     /// inherited from by the plug-in instance.
     //------------------------------------------------------------------
-    virtual
-    ~Process();
+    ~Process() override;
 
     //------------------------------------------------------------------
     /// Find a Process plug-in that can debug \a module using the
     /// currently selected architecture.
     ///
     /// Scans all loaded plug-in interfaces that implement versions of
     /// the Process plug-in interface and returns the first instance
     /// that can debug the file.
public:
     }
     
     void
     SetRunningUserExpression (bool on);
     
     //------------------------------------------------------------------
     // lldb::ExecutionContextScope pure virtual functions
     //------------------------------------------------------------------
-    virtual lldb::TargetSP
-    CalculateTarget ();
+    lldb::TargetSP
+    CalculateTarget()  override;
     
-    virtual lldb::ProcessSP
-    CalculateProcess ()
+    lldb::ProcessSP
+    CalculateProcess() override
     {
         return shared_from_this();
     }
     
-    virtual lldb::ThreadSP
-    CalculateThread ()
+    lldb::ThreadSP
+    CalculateThread() override
     {
         return lldb::ThreadSP();
     }
     
-    virtual lldb::StackFrameSP
-    CalculateStackFrame ()
+    lldb::StackFrameSP
+    CalculateStackFrame() override
     {
         return lldb::StackFrameSP();
     }
 
-    virtual void
-    CalculateExecutionContext (ExecutionContext &exe_ctx);
+    void
+    CalculateExecutionContext(ExecutionContext &exe_ctx) override;
     
     void
     SetSTDIOFileDescriptor (int file_descriptor);
 
     //------------------------------------------------------------------
     // Add a permanent region of memory that should never be read or 
     // written to. This can be used to ensure that memory reads or writes
     // to certain areas of memory never end up being sent to the 
protected:
     }
     
     // This is the completer for Attaching:
     class AttachCompletionHandler : public NextEventAction
     {
     public:
         AttachCompletionHandler (Process *process, uint32_t exec_count);
 
-        virtual
-        ~AttachCompletionHandler() 
+        ~AttachCompletionHandler() override
         {
         }
         
-        virtual EventActionResult PerformAction (lldb::EventSP &event_sp);
-        virtual EventActionResult HandleBeingInterrupted ();
-        virtual const char *GetExitString();
+        EventActionResult PerformAction(lldb::EventSP &event_sp) override;
+        EventActionResult HandleBeingInterrupted() override;
+        const char *GetExitString() override;
+
     private:
         uint32_t m_exec_count;
         std::string m_exit_string;
     };
 
     bool 
     HijackPrivateProcessEvents (Listener *listener);
     
protected:
     HaltForDestroyOrDetach(lldb::EventSP &exit_event_sp);
 
     bool
     StateChangedIsExternallyHijacked();
 
     void
     LoadOperatingSystemPlugin(bool flush);
 private:
+
     //------------------------------------------------------------------
     // For Process only
     //------------------------------------------------------------------
     void ControlPrivateStateThread (uint32_t signal);
     
     DISALLOW_COPY_AND_ASSIGN (Process);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Process_h_
+#endif // liblldb_Process_h_

lldb/trunk/include/lldb/Target/StackFrame.h

public:
     StackFrame (const lldb::ThreadSP &thread_sp,
                 lldb::user_id_t frame_idx, 
                 lldb::user_id_t concrete_frame_idx, 
                 const lldb::RegisterContextSP &reg_context_sp, 
                 lldb::addr_t cfa, 
                 const Address& pc, 
                 const SymbolContext *sc_ptr);
 
-    virtual ~StackFrame ();
+    ~StackFrame() override;
 
     lldb::ThreadSP
     GetThread () const
     {
         return m_thread_wp.lock();
     }
 
     StackID&
public:
     //    A ValueObject for this variable.
     //------------------------------------------------------------------
     lldb::ValueObjectSP
     TrackGlobalVariable (const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic);
 
     //------------------------------------------------------------------
     // lldb::ExecutionContextScope pure virtual functions
     //------------------------------------------------------------------
-    virtual lldb::TargetSP
-    CalculateTarget ();
+    lldb::TargetSP
+    CalculateTarget() override;
 
-    virtual lldb::ProcessSP
-    CalculateProcess ();
+    lldb::ProcessSP
+    CalculateProcess() override;
 
-    virtual lldb::ThreadSP
-    CalculateThread ();
+    lldb::ThreadSP
+    CalculateThread() override;
 
-    virtual lldb::StackFrameSP
-    CalculateStackFrame ();
+    lldb::StackFrameSP
+    CalculateStackFrame() override;
 
     void
-    CalculateExecutionContext (ExecutionContext &exe_ctx);
+    CalculateExecutionContext(ExecutionContext &exe_ctx) override;
 
 protected:
     friend class StackFrameList;
 
     void
     SetSymbolContextScope (SymbolContextScope *symbol_scope);
 
     void
private:
     ValueObjectList m_variable_list_value_objects;  // Value objects for each variable in m_variable_list_sp
     StreamString m_disassembly;
     Mutex m_mutex;
     DISALLOW_COPY_AND_ASSIGN (StackFrame);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_StackFrame_h_
+#endif // liblldb_StackFrame_h_

lldb/trunk/include/lldb/Target/SystemRuntime.h

public:
     SystemRuntime(lldb_private::Process *process);
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual since this class is designed to be
     /// inherited by the plug-in instance.
     //------------------------------------------------------------------
-    virtual
-    ~SystemRuntime();
+    ~SystemRuntime() override;
 
     //------------------------------------------------------------------
     /// Called after attaching to a process.
     ///
     /// Allow the SystemRuntime plugin to execute some code after attaching
     /// to a process. 
     //------------------------------------------------------------------
     virtual void
protected:
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     Process *m_process;
 
     std::vector<ConstString> m_types;
 
 private:
+
     DISALLOW_COPY_AND_ASSIGN (SystemRuntime);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_SystemRuntime_h_
+#endif // liblldb_SystemRuntime_h_

lldb/trunk/include/lldb/Target/TargetList.h

enum
         eBroadcastBitInterrupt = (1 << 0)
     };
 
 
     // These two functions fill out the Broadcaster interface:
     
     static ConstString &GetStaticBroadcasterClass ();
 
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }
 
-    virtual ~TargetList();
+    ~TargetList() override;
 
     //------------------------------------------------------------------
     /// Create a new Target.
     ///
     /// Clients must use this function to create a Target. This allows
     /// a global list of targets to be maintained in a central location
     /// so signal handlers and other global functions can use it to
     /// locate an appropriate target to deliver asynchronous information
protected:
     typedef std::vector<lldb::TargetSP> collection;
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     collection m_target_list;
     lldb::TargetSP m_dummy_target_sp;
     mutable Mutex m_target_list_mutex;
     uint32_t m_selected_target_idx;
+
 private:
+
     lldb::TargetSP
     GetDummyTarget (lldb_private::Debugger &debugger);
 
     Error
     CreateDummyTarget (Debugger &debugger,
                        const char *specified_arch_name,
                        lldb::TargetSP &target_sp);
 
CreateTargetInternal (Debugger &debugger,
                           lldb::TargetSP &target_sp,
                           bool is_dummy_target);
 
     DISALLOW_COPY_AND_ASSIGN (TargetList);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_TargetList_h_
+#endif // liblldb_TargetList_h_

lldb/trunk/include/lldb/Target/Thread.h

 
 namespace lldb_private {
 
 class ThreadProperties : public Properties
 {
 public:
     ThreadProperties(bool is_global);
     
-    virtual
-    ~ThreadProperties();
+    ~ThreadProperties() override;
     
     //------------------------------------------------------------------
     /// The regular expression returned determines symbols that this
     /// thread won't stop in during "step-in" operations.
     ///
     /// @return
     ///    A pointer to a regular expression to compare against symbols,
     ///    or NULL if all symbols are allowed.
enum
         eBroadcastBitThreadSuspended        = (1 << 1),
         eBroadcastBitThreadResumed          = (1 << 2),
         eBroadcastBitSelectedFrameChanged   = (1 << 3),
         eBroadcastBitThreadSelected         = (1 << 4)
     };
 
     static ConstString &GetStaticBroadcasterClass ();
     
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }
     
     class ThreadEventData :
         public EventData
     {
     public:
         ThreadEventData (const lldb::ThreadSP thread_sp);
         
         ThreadEventData (const lldb::ThreadSP thread_sp, const StackID &stack_id);
         
         ThreadEventData();
         
-        virtual ~ThreadEventData();
+        ~ThreadEventData() override;
         
         static const ConstString &
         GetFlavorString ();
 
-        virtual const ConstString &
-        GetFlavor () const
+        const ConstString &
+        GetFlavor() const override
         {
             return ThreadEventData::GetFlavorString ();
         }
         
-        virtual void
-        Dump (Stream *s) const;
+        void
+        Dump(Stream *s) const override;
     
         static const ThreadEventData *
         GetEventDataFromEvent (const Event *event_ptr);
         
         static lldb::ThreadSP
         GetThreadFromEvent (const Event *event_ptr);
         
         static StackID
public:
     ///     a thread from earlier in the program execution.  We may have the 
     ///     tid of the original thread that they represent but we don't want 
     ///     to reuse the IndexID of that thread, or create a new one.  If a
     ///     client wants to know the original thread's IndexID, they should use
     ///     Thread::GetExtendedBacktraceOriginatingIndexID().
     //------------------------------------------------------------------
     Thread (Process &process, lldb::tid_t tid, bool use_invalid_index_id = false);
 
-    virtual ~Thread();
+    ~Thread() override;
 
     lldb::ProcessSP
     GetProcess() const
     {
         return m_process_wp.lock(); 
     }
 
     int
public:
     GetProtocolID () const
     {
         return GetID();
     }
 
     //------------------------------------------------------------------
     // lldb::ExecutionContextScope pure virtual functions
     //------------------------------------------------------------------
-    virtual lldb::TargetSP
-    CalculateTarget ();
+    lldb::TargetSP
+    CalculateTarget() override;
     
-    virtual lldb::ProcessSP
-    CalculateProcess ();
+    lldb::ProcessSP
+    CalculateProcess() override;
     
-    virtual lldb::ThreadSP
-    CalculateThread ();
+    lldb::ThreadSP
+    CalculateThread() override;
     
-    virtual lldb::StackFrameSP
-    CalculateStackFrame ();
+    lldb::StackFrameSP
+    CalculateStackFrame() override;
 
-    virtual void
-    CalculateExecutionContext (ExecutionContext &exe_ctx);
+    void
+    CalculateExecutionContext(ExecutionContext &exe_ctx) override;
     
     lldb::StackFrameSP
     GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr);
     
     size_t
     GetStatus (Stream &strm, 
                uint32_t start_frame, 
                uint32_t num_frames,

 private:
     bool                m_extended_info_fetched;  // Have we tried to retrieve the m_extended_info for this thread?
     StructuredData::ObjectSP m_extended_info;     // The extended info for this thread
     //------------------------------------------------------------------
     // For Thread only
     //------------------------------------------------------------------
 
     DISALLOW_COPY_AND_ASSIGN (Thread);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Thread_h_
+#endif // liblldb_Thread_h_

lldb/trunk/include/lldb/Target/ThreadList.h

 friend class Process;
 
 public:
 
     ThreadList (Process *process);
 
     ThreadList (const ThreadList &rhs);
 
-    virtual
-    ~ThreadList ();
+    ~ThreadList() override;
 
     const ThreadList&
     operator = (const ThreadList& rhs);
 
     uint32_t
     GetSize(bool can_update = true);
 
     // Return the selected thread if there is one.  Otherwise, return the thread
public:
     DiscardThreadPlans();
 
     uint32_t
     GetStopID () const;
 
     void
     SetStopID (uint32_t stop_id);
 
-    virtual Mutex &
-    GetMutex ();
+    Mutex &
+    GetMutex() override;
     
     void
     Update (ThreadList &rhs);
     
 protected:
 
     void
     SetShouldReportStop (Vote vote);
 
     void
     NotifySelectedThreadChanged (lldb::tid_t tid);
 
     //------------------------------------------------------------------
     // Classes that inherit from Process can see and modify these
     //------------------------------------------------------------------
     Process *m_process; ///< The process that manages this thread list.
     uint32_t m_stop_id; ///< The process stop ID that this thread list is valid for.
     lldb::tid_t m_selected_tid;  ///< For targets that need the notion of a current thread.
 
 private:
+
     ThreadList ();
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadList_h_
+#endif // liblldb_ThreadList_h_

lldb/trunk/include/lldb/Target/UnwindAssembly.h

 class UnwindAssembly :
    public std::enable_shared_from_this<UnwindAssembly>,
    public PluginInterface
 {
 public:
     static lldb::UnwindAssemblySP
     FindPlugin (const ArchSpec &arch);
 
-    virtual
-    ~UnwindAssembly();
+    ~UnwindAssembly() override;
 
     virtual bool
     GetNonCallSiteUnwindPlanFromAssembly (AddressRange& func, 
                                           Thread& thread, 
                                           UnwindPlan& unwind_plan) = 0;
 
     virtual bool
     AugmentUnwindPlanFromCallSite (AddressRange& func,

 
 private:
     UnwindAssembly(); // Outlaw default constructor
     DISALLOW_COPY_AND_ASSIGN (UnwindAssembly);
 };
 
 } // namespace lldb_private
 
-#endif //utility_UnwindAssembly_h_
-
-
+#endif // utility_UnwindAssembly_h_

lldb/trunk/include/lldb/Utility/JSON.h

public:
         JSONString ();
         JSONString (const char* s);
         JSONString (const std::string& s);
 
         JSONString (const JSONString& s) = delete;
         JSONString&
         operator = (const JSONString& s) = delete;
         
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONString> SP;
         
         std::string
         GetData () { return m_data; }
         
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::String;
         }
         
-        virtual
-        ~JSONString () = default;
+        ~JSONString() override = default;
         
     private:
         
         static std::string
         json_string_quote_metachars (const std::string&);
         
         std::string m_data;
     };
 
     class JSONNumber : public JSONValue
     {
     public:
         JSONNumber ();
         explicit JSONNumber (uint64_t i);
         explicit JSONNumber (double d);
 
         JSONNumber (const JSONNumber& s) = delete;
         JSONNumber&
         operator = (const JSONNumber& s) = delete;
 
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONNumber> SP;
 
         uint64_t
         GetData () { return m_data; }
 
         double
         GetAsDouble()
         {
             if (m_is_integer)
                 return (double)m_data;
             else
                 return m_double;
         }
 
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::Number;
         }
         
-        virtual
-        ~JSONNumber () = default;
+        ~JSONNumber() override = default;
         
     private:
         bool m_is_integer;
         uint64_t m_data;
         double m_double;
     };
 
     class JSONTrue : public JSONValue
     {
     public:
         JSONTrue ();
 
         JSONTrue (const JSONTrue& s) = delete;
         JSONTrue&
         operator = (const JSONTrue& s) = delete;
         
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONTrue> SP;
         
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::True;
         }
         
-        virtual
-        ~JSONTrue () = default;
+        ~JSONTrue() override = default;
     };
 
     class JSONFalse : public JSONValue
     {
     public:
         JSONFalse ();
 
         JSONFalse (const JSONFalse& s) = delete;
         JSONFalse&
         operator = (const JSONFalse& s) = delete;
         
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONFalse> SP;
         
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::False;
         }
         
-        virtual
-        ~JSONFalse () = default;
+        ~JSONFalse() override = default;
     };
 
     class JSONNull : public JSONValue
     {
     public:
         JSONNull ();
 
         JSONNull (const JSONNull& s) = delete;
         JSONNull&
         operator = (const JSONNull& s) = delete;
         
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONNull> SP;
         
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::Null;
         }
         
-        virtual
-        ~JSONNull () = default;
+        ~JSONNull() override = default;
     };
 
     class JSONObject : public JSONValue
     {
     public:
         JSONObject ();
         
         JSONObject (const JSONObject& s) = delete;
         JSONObject&
         operator = (const JSONObject& s) = delete;
 
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONObject> SP;
         
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::Object;
         }
         
         bool
         SetObject (const std::string& key,
                    JSONValue::SP value);
         
         JSONValue::SP
         GetObject (const std::string& key);
         
-        virtual
-        ~JSONObject () = default;
+        ~JSONObject() override = default;
         
     private:
         typedef std::map<std::string, JSONValue::SP> Map;
         typedef Map::iterator Iterator;
         Map m_elements;
     };
 
     class JSONArray : public JSONValue
     {
     public:
         JSONArray ();
         
         JSONArray (const JSONArray& s) = delete;
         JSONArray&
         operator = (const JSONArray& s) = delete;
         
-        virtual void
-        Write (Stream& s);
+        void
+        Write(Stream& s) override;
         
         typedef std::shared_ptr<JSONArray> SP;
         
         static bool classof(const JSONValue *V)
         {
             return V->GetKind() == JSONValue::Kind::Array;
         }
         
public:
         AppendObject (JSONValue::SP value);
         
         JSONValue::SP
         GetObject (Index i);
         
         Size
         GetNumElements ();
 
-        virtual
-        ~JSONArray () = default;
+        ~JSONArray() override = default;
         
         Vector m_elements;
     };
 
-
     class JSONParser : public StringExtractor
     {
     public:
         enum Token
         {
             Invalid,
             Error,
             ObjectStart,
namespace lldb_private {
 
     protected:
         JSONValue::SP
         ParseJSONObject ();
 
         JSONValue::SP
         ParseJSONArray ();
     };
-}
+} // namespace lldb_private
 
-#endif // utility_ProcessStructReader_h_
+#endif // utility_JSON_h_

lldb/trunk/include/lldb/Utility/SharedCluster.h

namespace imp
     template <typename T>
     class shared_ptr_refcount : public lldb_private::imp::shared_count
     {
     public:
         template<class Y> shared_ptr_refcount (Y *in) : shared_count (0), manager(in) {}
         
         shared_ptr_refcount() : shared_count (0) {}
         
-        virtual ~shared_ptr_refcount ()
+        ~shared_ptr_refcount() override
         {
         }
         
-        virtual void on_zero_shared ()
+        void on_zero_shared() override
         {
             manager->DecrementRefCount();
         }
+
     private:
         T *manager;
     };
 
 } // namespace imp
 
 template <class T>
 class ClusterManager
private:
     friend class imp::shared_ptr_refcount<ClusterManager>;
     
     llvm::SmallPtrSet<T *, 16> m_objects;
     int m_external_ref;
     Mutex m_mutex;
 };
 
 } // namespace lldb_private
+
 #endif // utility_SharedCluster_h_

lldb/trunk/include/lldb/Utility/SharingPtr.h

class shared_ptr_pointer
     : public shared_count
 {
     T data_;
 public:
     shared_ptr_pointer(T p)
         :  data_(p) {}
 
 private:
-    virtual void on_zero_shared();
+    void on_zero_shared() override;
 
     // Outlaw copy constructor and assignment operator to keep effective C++
     // warnings down to a minimum
     shared_ptr_pointer (const shared_ptr_pointer &);
     shared_ptr_pointer & operator=(const shared_ptr_pointer &);
 };
 
 template <class T>
template <class A0, class A1, class A2, class A3>
         shared_ptr_emplace(A0& a0, A1& a1, A2& a2, A3& a3)
             :  data_(a0, a1, a2, a3) {}
 
     template <class A0, class A1, class A2, class A3, class A4>
         shared_ptr_emplace(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
             :  data_(a0, a1, a2, a3, a4) {}
 
 private:
-    virtual void on_zero_shared();
+    void on_zero_shared() override;
+
 public:
     T* get() {return &data_;}
 };
 
 template <class T>
 void
 shared_ptr_emplace<T>::on_zero_shared()
 {

 class ReferenceCountedBaseVirtual : public imp::shared_count
 {
 public:
     explicit ReferenceCountedBaseVirtual () : 
         imp::shared_count(-1)
     {
     }
     
-    virtual
-    ~ReferenceCountedBaseVirtual ()
+    ~ReferenceCountedBaseVirtual() override
     {
     }
     
-    virtual void on_zero_shared ();
-    
+    void on_zero_shared() override;
 };
 
 template <class T>
 void
 ReferenceCountedBaseVirtual<T>::on_zero_shared()
 {
 }
 

 template<class T, class U>
 inline bool operator!= (T* lhs, const IntrusiveSharingPtr<U>& rhs)
 {
     return lhs != rhs.get();
 }
 
 } // namespace lldb_private
 
-#endif  // utility_SharingPtr_h_
+#endif // utility_SharingPtr_h_