[LLDB] Fix Clang-tidy misc-use-override warnings in 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]

committed as r246626

lldb/trunk/include/lldb/Target/InstrumentationRuntimeStopInfo.h

 #include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
 
 class InstrumentationRuntimeStopInfo : public StopInfo
 {
 public:
     
-    virtual ~InstrumentationRuntimeStopInfo()
+    ~InstrumentationRuntimeStopInfo() override
     {
     }
     
-    virtual lldb::StopReason
-    GetStopReason () const
+    lldb::StopReason
+    GetStopReason() const override
     {
         return lldb::eStopReasonInstrumentation;
     }
     
-    virtual const char *
-    GetDescription ();
+    const char *
+    GetDescription() override;
 
-    virtual bool
-    DoShouldNotify (Event *event_ptr)
+    bool
+    DoShouldNotify(Event *event_ptr) override
     {
         return true;
     }
     
     static lldb::StopInfoSP
     CreateStopReasonWithInstrumentationData (Thread &thread, std::string description, StructuredData::ObjectSP additional_data);
     
 private:
     
     InstrumentationRuntimeStopInfo(Thread &thread, std::string description, StructuredData::ObjectSP additional_data);
-    
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_InstrumentationRuntimeStopInfo_h_
+#endif // liblldb_InstrumentationRuntimeStopInfo_h_

lldb/trunk/include/lldb/Target/JITLoader.h

public:
     static void 
     LoadPlugins (Process *process, lldb_private::JITLoaderList &list);
 
     //------------------------------------------------------------------
     /// Construct with a process.
     //------------------------------------------------------------------
     JITLoader (Process *process);
 
-    virtual 
-    ~JITLoader ();
+    ~JITLoader() override;
 
     //------------------------------------------------------------------
     /// Called after attaching a process.
     ///
     /// Allow JITLoader plug-ins to execute some code after
     /// attaching to a process.
     //------------------------------------------------------------------
     virtual void

lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h

protected:
         std::unique_ptr<ClangASTContext> m_scratch_ast_ctx_ap;
     };
 
     class ObjCExceptionPrecondition : public Breakpoint::BreakpointPrecondition
     {
     public:
         ObjCExceptionPrecondition();
 
-        virtual ~ObjCExceptionPrecondition() {}
+        ~ObjCExceptionPrecondition() override {}
 
         bool EvaluatePrecondition(StoppointCallbackContext &context) override;
         void DescribePrecondition(Stream &stream, lldb::DescriptionLevel level) override;
         Error ConfigurePrecondition(Args &args) override;
 
     protected:
         void AddClassName(const char *class_name);
 
public:
     GetClassDescriptorFromClassName (const ConstString &class_name);
 
     virtual ClassDescriptorSP
     GetClassDescriptorFromISA (ObjCISA isa);
 
     ClassDescriptorSP
     GetNonKVOClassDescriptor (ObjCISA isa);
     
-    virtual
-    ~ObjCLanguageRuntime();
+    ~ObjCLanguageRuntime() override;
     
     lldb::LanguageType
     GetLanguageType () const override
     {
         return lldb::eLanguageTypeObjC;
     }
     
     virtual bool
protected:
     //------------------------------------------------------------------
     ObjCLanguageRuntime(Process *process);
     
     virtual bool CalculateHasNewLiteralsAndIndexing()
     {
         return false;
     }
     
-    
     bool
     ISAIsCached (ObjCISA isa) const
     {
         return m_isa_to_descriptor.find(isa) != m_isa_to_descriptor.end();
     }
 
     bool
     AddClass (ObjCISA isa, const ClassDescriptorSP &descriptor_sp)
private:
     
     struct ClassAndSel
     {
         ClassAndSel()
         {
             sel_addr = LLDB_INVALID_ADDRESS;
             class_addr = LLDB_INVALID_ADDRESS;
         }
+
         ClassAndSel (lldb::addr_t in_sel_addr, lldb::addr_t in_class_addr) :
             class_addr (in_class_addr),
             sel_addr(in_sel_addr)
         {
         }
+
         bool operator== (const ClassAndSel &rhs)
         {
             if (class_addr == rhs.class_addr
                 && sel_addr == rhs.sel_addr)
                 return true;
             else
                 return false;
         }
protected:
     void
     ReadObjCLibraryIfNeeded (const ModuleList &module_list);
 
     DISALLOW_COPY_AND_ASSIGN (ObjCLanguageRuntime);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ObjCLanguageRuntime_h_
+#endif // liblldb_ObjCLanguageRuntime_h_

lldb/trunk/include/lldb/Target/RegisterContext.h

class RegisterContext :
     public ExecutionContextScope
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     RegisterContext (Thread &thread, uint32_t concrete_frame_idx);
 
-    virtual
-    ~RegisterContext ();
+    ~RegisterContext() override;
 
     void
     InvalidateIfNeeded (bool force);
 
     //------------------------------------------------------------------
     // Subclasses must override these functions
     //------------------------------------------------------------------
     virtual void
public:
     uint64_t
     ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value);
     
     bool
     WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval);
 
     bool
     WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval);
+
     bool
     ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint32_t source_regnum, lldb::RegisterKind target_rk, uint32_t& target_regnum);
 
     //------------------------------------------------------------------
     // 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;
 
     uint32_t
     GetStopID () const
     {
         return m_stop_id;
     }
 
     void
private:
     //------------------------------------------------------------------
     // For RegisterContext only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (RegisterContext);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_RegisterContext_h_
+#endif // liblldb_RegisterContext_h_

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

 //----------------------------------------------------------------------
 // TargetProperties
 //----------------------------------------------------------------------
 class TargetProperties : public Properties
 {
 public:
     TargetProperties(Target *target);
 
-    virtual
-    ~TargetProperties();
+    ~TargetProperties() override;
     
     ArchSpec
     GetDefaultArchitecture () const;
     
     void
     SetDefaultArchitecture (const ArchSpec& arch);
 
     bool
enum
         eBroadcastBitWatchpointChanged  = (1 << 3),
         eBroadcastBitSymbolsLoaded      = (1 << 4)
     };
     
     // These two functions fill out the Broadcaster interface:
     
     static ConstString &GetStaticBroadcasterClass ();
 
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }
 
     // This event data class is for use by the TargetList to broadcast new target notifications.
     class TargetEventData : public EventData
     {
     public:
         TargetEventData (const lldb::TargetSP &target_sp);
 
         TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list);
 
-        virtual
-        ~TargetEventData();
+        ~TargetEventData() override;
 
         static const ConstString &
         GetFlavorString ();
 
-        virtual const ConstString &
-        GetFlavor () const
+        const ConstString &
+        GetFlavor() const override
         {
             return TargetEventData::GetFlavorString ();
         }
 
-        virtual void
-        Dump (Stream *s) const;
+        void
+        Dump(Stream *s) const override;
 
         static const TargetEventData *
         GetEventDataFromEvent (const Event *event_ptr);
 
         static lldb::TargetSP
         GetTargetFromEvent (const Event *event_ptr);
 
         static ModuleList
//    UpdateInstanceName ();
 
     //----------------------------------------------------------------------
     // Settings accessors
     //----------------------------------------------------------------------
 
     static const lldb::TargetPropertiesSP &
     GetGlobalProperties();
 
-
 private:
     //------------------------------------------------------------------
     /// Construct with optional file and arch.
     ///
     /// This member is private. Clients must use
     /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
     /// so all targets can be tracked from the central target list.
     ///
private:
     // Copy breakpoints, stop hooks and so forth from the dummy target:
     void
     PrimeFromDummyTarget(Target *dummy_target);
 
     void
     AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal);
 
 public:
-    ~Target();
+    ~Target() override;
 
     Mutex &
     GetAPIMutex ()
     {
         return m_mutex;
     }
 
     void
CreateBreakpoint (const FileSpecList *containingModules,
                       const FileSpecList *containingSourceFiles,
                       const std::vector<std::string> &func_names,
                       uint32_t func_name_type_mask,
                       lldb::LanguageType language,
                       LazyBool skip_prologue,
                       bool internal,
                       bool request_hardware);
 
-
     // Use this to create a general breakpoint:
     lldb::BreakpointSP
     CreateBreakpoint (lldb::SearchFilterSP &filter_sp,
                       lldb::BreakpointResolverSP &resolver_sp,
                       bool internal,
                       bool request_hardware,
                       bool resolve_indirect_symbols);
 
public:
     lldb::addr_t
     GetBreakableLoadAddress (lldb::addr_t addr);
 
 protected:
     //------------------------------------------------------------------
     /// Implementing of ModuleList::Notifier.
     //------------------------------------------------------------------
     
-    virtual void
-    ModuleAdded (const ModuleList& module_list, const lldb::ModuleSP& module_sp);
+    void
+    ModuleAdded(const ModuleList& module_list, const lldb::ModuleSP& module_sp) override;
     
-    virtual void
-    ModuleRemoved (const ModuleList& module_list, const lldb::ModuleSP& module_sp);
+    void
+    ModuleRemoved(const ModuleList& module_list, const lldb::ModuleSP& module_sp) override;
     
-    virtual void
-    ModuleUpdated (const ModuleList& module_list,
-                   const lldb::ModuleSP& old_module_sp,
-                   const lldb::ModuleSP& new_module_sp);
-    virtual void
-    WillClearList (const ModuleList& module_list);
+    void
+    ModuleUpdated(const ModuleList& module_list,
+      const lldb::ModuleSP& old_module_sp,
+      const lldb::ModuleSP& new_module_sp) override;
+    void
+    WillClearList(const ModuleList& module_list) override;
 
 public:
     
     void
     ModulesDidLoad (ModuleList &module_list);
 
     void
     ModulesDidUnload (ModuleList &module_list, bool delete_locations);
//    }
 
     static Target *
     GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, 
                            const SymbolContext *sc_ptr);
 
     //------------------------------------------------------------------
     // 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;
 
     PathMappingList &
     GetImageSearchPathList ();
     
     ClangASTContext *
     GetScratchClangASTContext(bool create_on_demand=true);
     
     ClangASTImporter *
ImageSearchPathsChanged (const PathMappingList &path_list,
                              void *baton);
 
 private:
     DISALLOW_COPY_AND_ASSIGN (Target);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Target_h_
+#endif // liblldb_Target_h_

lldb/trunk/include/lldb/Target/ThreadPlan.h

 //===-- ThreadPlan.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_ThreadPlan_h_
 #define liblldb_ThreadPlan_h_
 
 // C Includes
 // C++ Includes
 #include <string>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/UserID.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
public:
     virtual size_t
     GetIterationCount ()
     {
         if (!m_takes_iteration_count)
             return 0;
         else
             return m_iteration_count;
     }
+
 protected:
     //------------------------------------------------------------------
     // Classes that inherit from ThreadPlan can see and modify these
     //------------------------------------------------------------------
 
     virtual bool
     DoWillResume (lldb::StateType resume_state, bool current_plan) { return true; }
 

 // accidentally access a thread after it is destroyed you won't crash.
 // But asking questions of the ThreadPlanNull is definitely an error.
 //----------------------------------------------------------------------
 
 class ThreadPlanNull : public ThreadPlan
 {
 public:
     ThreadPlanNull (Thread &thread);
-    virtual ~ThreadPlanNull ();
+    ~ThreadPlanNull() override;
     
-    virtual void
-    GetDescription (Stream *s,
-                    lldb::DescriptionLevel level);
+    void
+    GetDescription(Stream *s,
+       lldb::DescriptionLevel level) override;
 
-    virtual bool
-    ValidatePlan (Stream *error);
+    bool
+    ValidatePlan(Stream *error) override;
 
-    virtual bool
-    ShouldStop (Event *event_ptr);
+    bool
+    ShouldStop(Event *event_ptr) override;
 
-    virtual bool
-    MischiefManaged ();
+    bool
+    MischiefManaged() override;
 
-    virtual bool
-    WillStop ();
+    bool
+    WillStop() override;
 
-    virtual bool
-    IsBasePlan()
+    bool
+    IsBasePlan() override
     {
         return true;
     }
     
-    virtual bool
-    OkayToDiscard ()
+    bool
+    OkayToDiscard() override
     {
         return false;
     }
 
 protected:
-    virtual bool
-    DoPlanExplainsStop (Event *event_ptr);
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
     
-    virtual lldb::StateType
-    GetPlanRunState ();
+    lldb::StateType
+    GetPlanRunState() override;
 
     DISALLOW_COPY_AND_ASSIGN(ThreadPlanNull);
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlan_h_
+#endif // liblldb_ThreadPlan_h_

lldb/trunk/include/lldb/Target/ThreadPlanBase.h

 //  This is the generic version of the bottom most plan on the plan stack.  It should
 //  be able to handle generic breakpoint hitting, and signals and exceptions.
 //------------------------------------------------------------------
 
 class ThreadPlanBase : public ThreadPlan
 {
 friend class Process;  // RunThreadPlan manages "stopper" base plans.
 public:
-    virtual ~ThreadPlanBase ();
+    ~ThreadPlanBase() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual Vote ShouldReportStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    Vote ShouldReportStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
 
-    virtual bool OkayToDiscard()
+    bool
+    OkayToDiscard() override
     {
         return false;
     }
 
-    virtual bool
-    IsBasePlan()
+    bool
+    IsBasePlan() override
     {
         return true;
     }
     
 protected:
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
+    bool DoPlanExplainsStop(Event *event_ptr) override;
     ThreadPlanBase (Thread &thread);
 
 private:
     friend lldb::ThreadPlanSP
     Thread::QueueFundamentalPlan(bool abort_other_plans);
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanBase);
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanFundamental_h_
+#endif // liblldb_ThreadPlanFundamental_h_

lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h

ThreadPlanCallFunction (Thread &thread,
                             const CompilerType &return_type,
                             llvm::ArrayRef<lldb::addr_t> args,
                             const EvaluateExpressionOptions &options);
 
     ThreadPlanCallFunction(Thread &thread,
                            const Address &function,
                            const EvaluateExpressionOptions &options);
 
-    virtual
-    ~ThreadPlanCallFunction ();
+    ~ThreadPlanCallFunction() override;
 
-    virtual void
-    GetDescription (Stream *s, lldb::DescriptionLevel level);
+    void
+    GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
-    virtual bool
-    ValidatePlan (Stream *error);
+    bool
+    ValidatePlan(Stream *error) override;
 
-    virtual bool
-    ShouldStop (Event *event_ptr);
+    bool
+    ShouldStop(Event *event_ptr) override;
     
-    virtual Vote
-    ShouldReportStop(Event *event_ptr);
+    Vote
+    ShouldReportStop(Event *event_ptr) override;
 
-    virtual bool
-    StopOthers ();
+    bool
+    StopOthers() override;
     
-    virtual lldb::StateType
-    GetPlanRunState ();
+    lldb::StateType
+    GetPlanRunState() override;
 
-    virtual void
-    DidPush ();
+    void
+    DidPush() override;
 
-    virtual bool
-    WillStop ();
+    bool
+    WillStop() override;
 
-    virtual bool
-    MischiefManaged ();
+    bool
+    MischiefManaged() override;
 
     // To get the return value from a function call you must create a 
     // lldb::ValueSP that contains a valid clang type in its context and call
     // RequestReturnValue. The ValueSP will be stored and when the function is
     // done executing, the object will check if there is a requested return 
     // value. If there is, the return value will be retrieved using the 
     // ABI::GetReturnValue() for the ABI in the process. Then after the thread
     // plan is complete, you can call "GetReturnValue()" to retrieve the value
     // that was extracted.
 
-    virtual lldb::ValueObjectSP
-    GetReturnValueObject ()
+    lldb::ValueObjectSP
+    GetReturnValueObject() override
     {
         return m_return_valobj_sp;
     }
 
     // Return the stack pointer that the function received
     // on entry.  Any stack address below this should be 
     // considered invalid after the function has been
     // cleaned up.
     lldb::addr_t
     GetFunctionStackPointer()
     {
         return m_function_sp;
     }
     
     // Classes that derive from ClangFunction, and implement
     // their own WillPop methods should call this so that the
     // thread state gets restored if the plan gets discarded.
-    virtual void
-    WillPop ();
+    void
+    WillPop() override;
     
     // If the thread plan stops mid-course, this will be the stop reason that interrupted us.
     // Once DoTakedown is called, this will be the real stop reason at the end of the function call.
     // If it hasn't been set for one or the other of these reasons, we'll return the PrivateStopReason.
     // This is needed because we want the CallFunction thread plans not to show up as the stop reason.
     // But if something bad goes wrong, it is nice to be able to tell the user what really happened.
 
-    virtual lldb::StopInfoSP
-    GetRealStopInfo()
+    lldb::StopInfoSP
+    GetRealStopInfo() override
     {
         if (m_real_stop_info_sp)
             return m_real_stop_info_sp;
         else
             return GetPrivateStopInfo ();
     }
     
     lldb::addr_t
     GetStopAddress ()
     {
         return m_stop_address;
     }
 
-    virtual bool
-    RestoreThreadState();
+    bool
+    RestoreThreadState() override;
     
-    virtual void
-    ThreadDestroyed ()
+    void
+    ThreadDestroyed() override
     {
         m_takedown_done = true;
     }
     
-    virtual void
-    SetStopOthers (bool new_value);
+    void
+    SetStopOthers(bool new_value) override;
     
 protected:
     void ReportRegisterState (const char *message);
 
-    virtual bool
-    DoPlanExplainsStop (Event *event_ptr);
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
 
     virtual void
     SetReturnValue();
 
     bool
     ConstructorSetup (Thread &thread,
                       ABI *& abi,
                       lldb::addr_t &start_load_addr,

 
 private:
     CompilerType                                    m_return_type;
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunction);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanCallFunction_h_
+#endif // liblldb_ThreadPlanCallFunction_h_

lldb/trunk/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h

 public:
     ThreadPlanCallFunctionUsingABI (Thread &thread,
                                  const Address &function_address,
                                  llvm::Type &function_prototype,
                                  llvm::Type &return_type,
                                  llvm::ArrayRef<ABI::CallArgument> args,
                                  const EvaluateExpressionOptions &options);
 
-    ~ThreadPlanCallFunctionUsingABI ();
+    ~ThreadPlanCallFunctionUsingABI() override;
 
     void
     GetDescription (Stream *s, lldb::DescriptionLevel level) override;
 
 protected:
     void
     SetReturnValue () override;
 
-
 private:
     llvm::Type                                     &m_return_type;
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunctionUsingABI);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanCallFunctionUsingABI_h_
+#endif // liblldb_ThreadPlanCallFunctionUsingABI_h_

lldb/trunk/include/lldb/Target/ThreadPlanCallUserExpression.h

 {
 public:
     ThreadPlanCallUserExpression (Thread &thread,
                                   Address &function,
                                   llvm::ArrayRef<lldb::addr_t> args,
                                   const EvaluateExpressionOptions &options,
                                   lldb::ClangUserExpressionSP &user_expression_sp);
     
-    virtual
-    ~ThreadPlanCallUserExpression ();
+    ~ThreadPlanCallUserExpression() override;
 
-    virtual void
-    GetDescription (Stream *s, lldb::DescriptionLevel level);
+    void
+    GetDescription(Stream *s, lldb::DescriptionLevel level) override;
     
-    virtual void
-    WillPop ();
+    void
+    WillPop() override;
 
-    virtual lldb::StopInfoSP
-    GetRealStopInfo();
+    lldb::StopInfoSP
+    GetRealStopInfo() override;
     
-    virtual bool
-    MischiefManaged ();
+    bool
+    MischiefManaged() override;
     
     void
     TransferExpressionOwnership ()
     {
         m_manage_materialization = true;
     }
     
-    virtual lldb::ClangExpressionVariableSP
-    GetExpressionVariable ()
+    lldb::ClangExpressionVariableSP
+    GetExpressionVariable() override
     {
         return m_result_var_sp;
     }
     
 protected:
 private:
     lldb::ClangUserExpressionSP m_user_expression_sp;    // This is currently just used to ensure the
                                                          // User expression the initiated this ThreadPlan
                                                          // lives as long as the thread plan does.
     bool m_manage_materialization = false;
     lldb::ClangExpressionVariableSP m_result_var_sp;     // If we are left to manage the materialization,
                                                          // then stuff the result expression variable here.
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallUserExpression);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanCallUserExpression_h_
+#endif // liblldb_ThreadPlanCallUserExpression_h_

lldb/trunk/include/lldb/Target/ThreadPlanPython.h

 //===-- ThreadPlanPython.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_ThreadPlan_Python_h_
 #define liblldb_ThreadPlan_Python_h_
 
 // C Includes
 // C++ Includes
 #include <string>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UserID.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanTracer.h"
 #include "lldb/Target/StopInfo.h"
 
 namespace lldb_private {
 
 //------------------------------------------------------------------
 //  ThreadPlanPython:
 //
 //------------------------------------------------------------------
 
 class ThreadPlanPython : public ThreadPlan
 {
 public:
     ThreadPlanPython (Thread &thread, const char *class_name);
-    virtual ~ThreadPlanPython ();
+    ~ThreadPlanPython() override;
     
-    virtual void
-    GetDescription (Stream *s,
-                    lldb::DescriptionLevel level);
+    void
+    GetDescription(Stream *s,
+       lldb::DescriptionLevel level) override;
 
-    virtual bool
-    ValidatePlan (Stream *error);
+    bool
+    ValidatePlan(Stream *error) override;
 
-    virtual bool
-    ShouldStop (Event *event_ptr);
+    bool
+    ShouldStop(Event *event_ptr) override;
 
-    virtual bool
-    MischiefManaged ();
+    bool
+    MischiefManaged() override;
 
-    virtual bool
-    WillStop ();
+    bool
+    WillStop() override;
 
-    virtual bool
-    StopOthers ();
+    bool
+    StopOthers() override;
 
-    virtual void
-    DidPush ();
+    void
+    DidPush() override;
 
 protected:
-    virtual bool
-    DoPlanExplainsStop (Event *event_ptr);
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
     
-    virtual lldb::StateType
-    GetPlanRunState ();
+    lldb::StateType
+    GetPlanRunState() override;
 
 private:
     std::string m_class_name;
     StructuredData::ObjectSP m_implementation_sp;
 
     DISALLOW_COPY_AND_ASSIGN(ThreadPlanPython);
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlan_Python_h_
+#endif // liblldb_ThreadPlan_Python_h_

lldb/trunk/include/lldb/Target/ThreadPlanRunToAddress.h

public:
     ThreadPlanRunToAddress (Thread &thread,
                             lldb::addr_t address,
                             bool stop_others);
 
     ThreadPlanRunToAddress (Thread &thread,
                             const std::vector<lldb::addr_t> &addresses,
                             bool stop_others);
 
+    ~ThreadPlanRunToAddress() override;
 
-    virtual
-    ~ThreadPlanRunToAddress ();
+    void
+    GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
-    virtual void
-    GetDescription (Stream *s, lldb::DescriptionLevel level);
+    bool
+    ValidatePlan(Stream *error) override;
 
-    virtual bool
-    ValidatePlan (Stream *error);
+    bool
+    ShouldStop(Event *event_ptr) override;
 
-    virtual bool
-    ShouldStop (Event *event_ptr);
+    bool
+    StopOthers() override;
     
-    virtual bool
-    StopOthers ();
+    void
+    SetStopOthers(bool new_value) override;
     
-    virtual void
-    SetStopOthers (bool new_value);
-    
-    virtual lldb::StateType
-    GetPlanRunState ();
+    lldb::StateType
+    GetPlanRunState() override;
+    bool
+    WillStop() override;
 
-    virtual bool
-    WillStop ();
-
-    virtual bool
-    MischiefManaged ();
+    bool
+    MischiefManaged() override;
 
 protected:
-    virtual bool
-    DoPlanExplainsStop (Event *event_ptr);
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
 
     void SetInitialBreakpoints();
     bool AtOurAddress();
 private:
     bool m_stop_others;
     std::vector<lldb::addr_t> m_addresses;   // This is the address we are going to run to.
                           // TODO: Would it be useful to have multiple addresses?
     std::vector<lldb::break_id_t> m_break_ids; // This is the breakpoint we are using to stop us at m_address.
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanRunToAddress);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanRunToAddress_h_
+#endif // liblldb_ThreadPlanRunToAddress_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepInRange.h

public:
     ThreadPlanStepInRange (Thread &thread,
                            const AddressRange &range,
                            const SymbolContext &addr_context,
                            const char *step_into_function_name,
                            lldb::RunMode stop_others,
                             LazyBool step_in_avoids_code_without_debug_info,
                             LazyBool step_out_avoids_code_without_debug_info);
 
-    virtual
-    ~ThreadPlanStepInRange ();
+    ~ThreadPlanStepInRange() override;
 
-    virtual void
-    GetDescription (Stream *s, lldb::DescriptionLevel level);
+    void
+    GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
-    virtual bool
-    ShouldStop (Event *event_ptr);
+    bool
+    ShouldStop(Event *event_ptr) override;
 
     void SetAvoidRegexp(const char *name);
     
     void SetStepInTarget (const char *target)
     {
         m_step_into_target.SetCString(target);
     }
     
     static void
     SetDefaultFlagValue (uint32_t new_value);
     
     bool
-    IsVirtualStep();
+    IsVirtualStep() override;
 
 protected:
     static bool
     DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation, void *baton);
 
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 
-    virtual bool
-    DoPlanExplainsStop (Event *event_ptr);
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
 
-    virtual void
-    SetFlagsToDefault ()
+    void
+    SetFlagsToDefault() override
     {
         GetFlags().Set(ThreadPlanStepInRange::s_default_flag_values);
     }
     
     void
     SetCallbacks()
     {
         ThreadPlanShouldStopHere::ThreadPlanShouldStopHereCallbacks callbacks(ThreadPlanStepInRange::DefaultShouldStopHereCallback, nullptr);
private:
     static uint32_t s_default_flag_values;  // These are the default flag values for the ThreadPlanStepThrough.
     lldb::ThreadPlanSP m_sub_plan_sp;  // Keep track of the last plan we were running.  If it fails, we should stop.
     std::unique_ptr<RegularExpression> m_avoid_regexp_ap;
     bool m_step_past_prologue;  // FIXME: For now hard-coded to true, we could put a switch in for this if there's
                                 // demand for that.
     bool m_virtual_step;        // true if we've just done a "virtual step", i.e. just moved the inline stack depth.
     ConstString m_step_into_target;
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepInRange);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepInRange_h_
+#endif // liblldb_ThreadPlanStepInRange_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepInstruction.h

 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepInstruction : public ThreadPlan
 {
 public:
-    virtual ~ThreadPlanStepInstruction ();
+    ~ThreadPlanStepInstruction() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual bool IsPlanStale ();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    bool IsPlanStale() override;
 
 protected:
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
+    bool DoPlanExplainsStop(Event *event_ptr) override;
 
     ThreadPlanStepInstruction (Thread &thread,
                                bool step_over,
                                bool stop_others,
                                Vote stop_vote,
                                Vote run_vote);
     void SetUpState ();
 
 private:
     friend lldb::ThreadPlanSP
     Thread::QueueThreadPlanForStepSingleInstruction (bool step_over, bool abort_other_plans, bool stop_other_threads);
 
     lldb::addr_t m_instruction_addr;
     bool m_stop_other_threads;
     bool m_step_over;
     // These two are used only for the step over case.
     bool m_start_has_symbol;
     StackID m_stack_id;
     StackID m_parent_frame_id;
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepInstruction);
-
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepInstruction_h_
+#endif // liblldb_ThreadPlanStepInstruction_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepOut.h

ThreadPlanStepOut (Thread &thread,
                        SymbolContext *addr_context,
                        bool first_insn,
                        bool stop_others,
                        Vote stop_vote,
                        Vote run_vote,
                        uint32_t frame_idx,
                        LazyBool step_out_avoids_code_without_debug_info);
 
-    virtual ~ThreadPlanStepOut ();
+    ~ThreadPlanStepOut() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual void DidPush();
-    virtual bool IsPlanStale();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    void DidPush() override;
+    bool IsPlanStale() override;
     
-    virtual lldb::ValueObjectSP GetReturnValueObject()
+    lldb::ValueObjectSP GetReturnValueObject() override
     {
         return m_return_valobj_sp;
     }
 
 protected:
-    virtual void
-    SetFlagsToDefault ()
+    void
+    SetFlagsToDefault() override
     {
         GetFlags().Set(ThreadPlanStepOut::s_default_flag_values);
     }
     
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoPlanExplainsStop (Event *event_ptr) override;
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
     bool QueueInlinedStepPlan (bool queue_now);
 
 private:
     static uint32_t s_default_flag_values;  // These are the default flag values for the ThreadPlanStepThrough.
     
     lldb::addr_t m_step_from_insn;
     StackID  m_step_out_to_id;
     StackID  m_immediate_step_from_id;
private:
     void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);
     // Need an appropriate marker for the current stack so we can tell step out
     // from step in.
 
     void
     CalculateReturnValue();
     
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepOut);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepOut_h_
+#endif // liblldb_ThreadPlanStepOut_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepOverBreakpoint.h

 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepOverBreakpoint : public ThreadPlan
 {
 public:
-    virtual ~ThreadPlanStepOverBreakpoint ();
-
     ThreadPlanStepOverBreakpoint (Thread &thread);
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual void ThreadDestroyed ();
-    void SetAutoContinue (bool do_it);
-    virtual bool ShouldAutoContinue(Event *event_ptr);
-    virtual bool IsPlanStale();
+
+    ~ThreadPlanStepOverBreakpoint() override;
+
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    void ThreadDestroyed() override;
+    void SetAutoContinue(bool do_it);
+    bool ShouldAutoContinue(Event *event_ptr) override;
+    bool IsPlanStale() override;
 
     lldb::addr_t
     GetBreakpointLoadAddress() const
     {
         return m_breakpoint_addr;
     }
+
 protected:
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoPlanExplainsStop(Event *event_ptr) override;
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 
     void ReenableBreakpointSite ();
 private:
 
     lldb::addr_t m_breakpoint_addr;
     lldb::user_id_t m_breakpoint_site_id;
     bool m_auto_continue;
     bool m_reenabled_breakpoint_site;
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepOverBreakpoint);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepOverBreakpoint_h_
+#endif // liblldb_ThreadPlanStepOverBreakpoint_h_