[LLDB] Fix Clang-tidy misc-use-override warnings in include/lldb/Expression and include/lldb/Initialization, unify 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 r245283.

lldb/trunk/include/lldb/Expression/ASTResultSynthesizer.h

public:
     ///     AST importer.
     //----------------------------------------------------------------------
     ASTResultSynthesizer(clang::ASTConsumer *passthrough,
                          Target &target);
     
     //----------------------------------------------------------------------
     /// Destructor
     //----------------------------------------------------------------------
-    ~ASTResultSynthesizer();
+    ~ASTResultSynthesizer() override;
     
     //----------------------------------------------------------------------
     /// Link this consumer with a particular AST context
     ///
     /// @param[in] Context
     ///     This AST context will be used for types and identifiers, and also
     ///     forwarded to the passthrough consumer, if one exists.
     //----------------------------------------------------------------------
-    void Initialize(clang::ASTContext &Context);
+    void Initialize(clang::ASTContext &Context) override;
     
     //----------------------------------------------------------------------
     /// Examine a list of Decls to find the function $__lldb_expr and 
     /// transform its code
     ///
     /// @param[in] D
     ///     The list of Decls to search.  These may contain LinkageSpecDecls,
     ///     which need to be searched recursively.  That job falls to
     ///     TransformTopLevelDecl.
     //----------------------------------------------------------------------
-    bool HandleTopLevelDecl(clang::DeclGroupRef D);
+    bool HandleTopLevelDecl(clang::DeclGroupRef D) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void HandleTranslationUnit(clang::ASTContext &Ctx);
+    void HandleTranslationUnit(clang::ASTContext &Ctx) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void HandleTagDeclDefinition(clang::TagDecl *D);
+    void HandleTagDeclDefinition(clang::TagDecl *D) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void CompleteTentativeDefinition(clang::VarDecl *D);
+    void CompleteTentativeDefinition(clang::VarDecl *D) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void HandleVTable(clang::CXXRecordDecl *RD);
+    void HandleVTable(clang::CXXRecordDecl *RD) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void PrintStats();
+    void PrintStats() override;
     
     //----------------------------------------------------------------------
     /// Set the Sema object to use when performing transforms, and pass it on
     ///
     /// @param[in] S
     ///     The Sema to use.  Because Sema isn't externally visible, this class
     ///     casts it to an Action for actual use.
     //----------------------------------------------------------------------
-    void InitializeSema(clang::Sema &S);
+    void InitializeSema(clang::Sema &S) override;
     
     //----------------------------------------------------------------------
     /// Reset the Sema to NULL now that transformations are done
     //----------------------------------------------------------------------
-    void ForgetSema();
+    void ForgetSema() override;
+
 private:
     //----------------------------------------------------------------------
     /// Hunt the given Decl for FunctionDecls named $__lldb_expr, recursing
     /// as necessary through LinkageSpecDecls, and calling SynthesizeResult on
     /// anything that was found
     ///
     /// @param[in] D
     ///     The Decl to hunt.
private:
     
     clang::ASTContext *m_ast_context;           ///< The AST context to use for identifiers and types.
     clang::ASTConsumer *m_passthrough;          ///< The ASTConsumer down the chain, for passthrough.  NULL if it's a SemaConsumer.
     clang::SemaConsumer *m_passthrough_sema;    ///< The SemaConsumer down the chain, for passthrough.  NULL if it's an ASTConsumer.
     Target &m_target;                           ///< The target, which contains the persistent variable store and the
     clang::Sema *m_sema;                        ///< The Sema to use.
 };
 
-}
+} // namespace lldb_private
 
-#endif
+#endif // liblldb_ASTResultSynthesizer_h_

lldb/trunk/include/lldb/Expression/ASTStructExtractor.h

public:
     //----------------------------------------------------------------------
     ASTStructExtractor(clang::ASTConsumer *passthrough,
                        const char *struct_name,
                        ClangFunction &function);
     
     //----------------------------------------------------------------------
     /// Destructor
     //----------------------------------------------------------------------
-    virtual ~ASTStructExtractor();
+    ~ASTStructExtractor() override;
     
     //----------------------------------------------------------------------
     /// Link this consumer with a particular AST context
     ///
     /// @param[in] Context
     ///     This AST context will be used for types and identifiers, and also
     ///     forwarded to the passthrough consumer, if one exists.
     //----------------------------------------------------------------------
-    void Initialize(clang::ASTContext &Context);
+    void Initialize(clang::ASTContext &Context) override;
     
     //----------------------------------------------------------------------
     /// Examine a list of Decls to find the function $__lldb_expr and 
     /// transform its code
     ///
     /// @param[in] D
     ///     The list of Decls to search.  These may contain LinkageSpecDecls,
     ///     which need to be searched recursively.  That job falls to
     ///     TransformTopLevelDecl.
     //----------------------------------------------------------------------
-    bool HandleTopLevelDecl(clang::DeclGroupRef D);
+    bool HandleTopLevelDecl(clang::DeclGroupRef D) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void HandleTranslationUnit(clang::ASTContext &Ctx);
+    void HandleTranslationUnit(clang::ASTContext &Ctx) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void HandleTagDeclDefinition(clang::TagDecl *D);
+    void HandleTagDeclDefinition(clang::TagDecl *D) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void CompleteTentativeDefinition(clang::VarDecl *D);
+    void CompleteTentativeDefinition(clang::VarDecl *D) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void HandleVTable(clang::CXXRecordDecl *RD);
+    void HandleVTable(clang::CXXRecordDecl *RD) override;
     
     //----------------------------------------------------------------------
     /// Passthrough stub
     //----------------------------------------------------------------------
-    void PrintStats();
+    void PrintStats() override;
     
     //----------------------------------------------------------------------
     /// Set the Sema object to use when performing transforms, and pass it on
     ///
     /// @param[in] S
     ///     The Sema to use.  Because Sema isn't externally visible, this class
     ///     casts it to an Action for actual use.
     //----------------------------------------------------------------------
-    void InitializeSema(clang::Sema &S);
+    void InitializeSema(clang::Sema &S) override;
     
     //----------------------------------------------------------------------
     /// Reset the Sema to NULL now that transformations are done
     //----------------------------------------------------------------------
-    void ForgetSema();
+    void ForgetSema() override;
+
 private:
     //----------------------------------------------------------------------
     /// Hunt the given FunctionDecl for the argument struct and place
     /// information about it into m_function
     ///
     /// @param[in] F
     ///     The FunctionDecl to hunt.
     //----------------------------------------------------------------------
private:
     clang::SemaConsumer            *m_passthrough_sema;     ///< The SemaConsumer down the chain, for passthrough.  NULL if it's an ASTConsumer.
     clang::Sema                    *m_sema;                 ///< The Sema to use.
     clang::Action                  *m_action;               ///< The Sema to use, cast to an Action so it's usable.
     
     ClangFunction                  &m_function;             ///< The function to populate with information about the argument structure.
     std::string                     m_struct_name;          ///< The name of the structure to extract.
 };
     
-}
+} // namespace lldb_private
 
-#endif
+#endif // liblldb_ASTStructExtractor_h_

lldb/trunk/include/lldb/Expression/ClangASTSource.h

ClangASTSource (const lldb::TargetSP &target) :
         m_active_lookups ()
     {
         m_ast_importer = m_target->GetClangASTImporter();
     }
   
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    ~ClangASTSource();
+    ~ClangASTSource() override;
     
     //------------------------------------------------------------------
     /// Interface stubs.
     //------------------------------------------------------------------
     clang::Decl *GetExternalDecl (uint32_t) override {   return NULL;                }
     clang::Stmt *GetExternalDeclStmt (uint64_t) override {   return NULL;                }
     clang::Selector GetExternalSelector (uint32_t) override {   return clang::Selector();   }
     uint32_t GetNumExternalSelectors () override {   return 0;                   }
struct NameSearchContext {
     ///
     /// @param[in] decl
     ///     The NamedDecl, usually returned as the result
     ///     of querying a DeclContext.
     //------------------------------------------------------------------
     void AddNamedDecl (clang::NamedDecl *decl);
 };
 
-}
+} // namespace lldb_private
 
-#endif
+#endif // liblldb_ClangASTSource_h_

lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h

public:
     ///     The execution context to use when parsing.
     //------------------------------------------------------------------
     ClangExpressionDeclMap (bool keep_result_in_memory,
                             ExecutionContext &exe_ctx);
     
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    ~ClangExpressionDeclMap ();
+    ~ClangExpressionDeclMap() override;
     
     //------------------------------------------------------------------
     /// Enable the state needed for parsing and IR transformation.
     ///
     /// @param[in] exe_ctx
     ///     The execution context to use when finding types for variables.
     ///     Also used to find a "scratch" AST context to store result types.
     ///
public:
     ///
     /// @param[in] context
     ///     The NameSearchContext that can construct Decls for this name.
     ///
     /// @return
     ///     True on success; false otherwise.
     //------------------------------------------------------------------
     void 
-    FindExternalVisibleDecls (NameSearchContext &context);
+    FindExternalVisibleDecls(NameSearchContext &context) override;
     
     //------------------------------------------------------------------
     /// Find all entities matching a given name in a given module/namespace,
     /// using a NameSearchContext to make Decls for them.
     ///
     /// @param[in] context
     ///     The NameSearchContext that can construct Decls for this name.
     ///
private:
 
     TypeFromParser
     CopyClassType(TypeFromUser &type,
                   unsigned int current_id);
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_ClangExpressionDeclMap_h_
+#endif // liblldb_ClangExpressionDeclMap_h_

lldb/trunk/include/lldb/Expression/ClangFunction.h

 //===-- ClangFunction.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef lldb_ClangFunction_h_
-#define lldb_ClangFunction_h_
+#ifndef liblldb_ClangFunction_h_
+#define liblldb_ClangFunction_h_
 
 // C Includes
 // C++ Includes
 #include <vector>
 #include <list>
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ClangForward.h"
ClangFunction (ExecutionContextScope &exe_scope,
                    const CompilerType &return_type,
                    const Address& function_address, 
                    const ValueList &arg_value_list,
                    const char *name);
     
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    virtual 
-    ~ClangFunction();
+    ~ClangFunction() override;
 
     //------------------------------------------------------------------
     /// Compile the wrapper function
     ///
     /// @param[in] errors
     ///     The stream to print parser errors to.
     ///
     /// @return
public:
     /// Interface for ClangExpression
     //------------------------------------------------------------------
     
     //------------------------------------------------------------------
     /// Return the string that the parser should parse.  Must be a full
     /// translation unit.
     //------------------------------------------------------------------
     const char *
-    Text ()
+    Text() override
     {
         return m_wrapper_function_text.c_str();
     }
     
     //------------------------------------------------------------------
     /// Return the function name that should be used for executing the
     /// expression.  Text() should contain the definition of this
     /// function.
     //------------------------------------------------------------------
     const char *
-    FunctionName ()
+    FunctionName() override
     {
         return m_wrapper_function_name.c_str();
     }
     
     //------------------------------------------------------------------
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     //------------------------------------------------------------------
     ClangExpressionDeclMap *
-    DeclMap ()
+    DeclMap() override
     {
         return NULL;
     }
     
     //------------------------------------------------------------------
     /// Return the object that the parser should use when registering
     /// local variables.  May be NULL if the Expression doesn't care.
     //------------------------------------------------------------------
     ClangExpressionVariableList *
     LocalVariables ()
     {
         return NULL;
     }
     
     //------------------------------------------------------------------
     /// Return the object that the parser should allow to access ASTs.
     /// May be NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
     ///     the ASTs to after transformation.
     //------------------------------------------------------------------
     clang::ASTConsumer *
-    ASTTransformer (clang::ASTConsumer *passthrough);
+    ASTTransformer(clang::ASTConsumer *passthrough) override;
     
     //------------------------------------------------------------------
     /// Return true if validation code should be inserted into the
     /// expression.
     //------------------------------------------------------------------
     bool
-    NeedsValidation ()
+    NeedsValidation() override
     {
         return false;
     }
     
     //------------------------------------------------------------------
     /// Return true if external variables in the expression should be
     /// resolved.
     //------------------------------------------------------------------
     bool
-    NeedsVariableResolution ()
+    NeedsVariableResolution() override
     {
         return false;
     }
     
     ValueList
     GetArgumentValues () const
     {
         return m_arg_values;
private:
     ValueList                       m_arg_values;                   ///< The default values of the arguments.
     
     bool                            m_compiled;                     ///< True if the wrapper function has already been parsed.
     bool                            m_JITted;                       ///< True if the wrapper function has already been JIT-compiled.
 };
 
 } // Namespace lldb_private
 
-#endif  // lldb_ClangFunction_h_
+#endif // liblldb_ClangFunction_h_

lldb/trunk/include/lldb/Expression/ClangModulesDeclVendor.h

 //===-- ClangModulesDeclVendor.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_ClangModulesDeclVendor_
-#define _liblldb_ClangModulesDeclVendor_
+#ifndef liblldb_ClangModulesDeclVendor_h
+#define liblldb_ClangModulesDeclVendor_h
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Target/Platform.h"
 
 #include <set>
 #include <vector>
 
 namespace lldb_private
 {
     
 class ClangModulesDeclVendor : public DeclVendor
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     ClangModulesDeclVendor();
     
-    virtual
-    ~ClangModulesDeclVendor();
+    ~ClangModulesDeclVendor() override;
     
     static ClangModulesDeclVendor *
     Create(Target &target);
     
     typedef std::vector<ConstString> ModulePath;
     typedef uintptr_t                ModuleID;
     typedef std::vector<ModuleID>    ModuleVector;
     
public:
     /// @param[in] language
     ///     The language to query for.
     ///
     /// @return
     ///     True if Clang has modules for the given language.
     //------------------------------------------------------------------
     static bool
     LanguageSupportsClangModules (lldb::LanguageType language);
-    
 };
     
-}
-#endif /* defined(_lldb_ClangModulesDeclVendor_) */
+} // namespace lldb_private
+
+#endif // liblldb_ClangModulesDeclVendor_h

lldb/trunk/include/lldb/Expression/ClangUserExpression.h

public:
     ClangUserExpression (const char *expr,
                          const char *expr_prefix,
                          lldb::LanguageType language,
                          ResultType desired_type);
 
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    virtual
-    ~ClangUserExpression ();
+    ~ClangUserExpression() override;
 
     //------------------------------------------------------------------
     /// Parse the expression
     ///
     /// @param[in] error_stream
     ///     A stream to print parse errors and warnings to.
     ///
     /// @param[in] exe_ctx
FinalizeJITExecution (Stream &error_stream,
                           lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS,
                           lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS);
 
     //------------------------------------------------------------------
     /// Return the string that the parser should parse.  Must be a full
     /// translation unit.
     //------------------------------------------------------------------
     const char *
-    Text ()
+    Text() override
     {
         return m_transformed_text.c_str();
     }
 
     //------------------------------------------------------------------
     /// Return the string that the user typed.
     //------------------------------------------------------------------
     const char *
     GetUserText ()
     {
         return m_expr_text.c_str();
     }
 
     //------------------------------------------------------------------
     /// Return the function name that should be used for executing the
     /// expression.  Text() should contain the definition of this
     /// function.
     //------------------------------------------------------------------
     const char *
-    FunctionName ()
+    FunctionName() override
     {
         return "$__lldb_expr";
     }
 
     //------------------------------------------------------------------
     /// Return the language that should be used when parsing.  To use
     /// the default, return eLanguageTypeUnknown.
     //------------------------------------------------------------------
-    virtual lldb::LanguageType
-    Language ()
+    lldb::LanguageType
+    Language() override
     {
         return m_language;
     }
 
     //------------------------------------------------------------------
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     //------------------------------------------------------------------
     ClangExpressionDeclMap *
-    DeclMap ()
+    DeclMap() override
     {
         return m_expr_decl_map.get();
     }
 
     //------------------------------------------------------------------
     /// Return the object that the parser should allow to access ASTs.
     /// May be NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
     ///     the ASTs to after transformation.
     //------------------------------------------------------------------
     clang::ASTConsumer *
-    ASTTransformer (clang::ASTConsumer *passthrough);
+    ASTTransformer(clang::ASTConsumer *passthrough) override;
 
     //------------------------------------------------------------------
     /// Return the desired result type of the function, or
     /// eResultTypeAny if indifferent.
     //------------------------------------------------------------------
-    virtual ResultType
-    DesiredResultType ()
+    ResultType
+    DesiredResultType() override
     {
         return m_desired_type;
     }
 
     //------------------------------------------------------------------
     /// Return true if validation code should be inserted into the
     /// expression.
     //------------------------------------------------------------------
     bool
-    NeedsValidation ()
+    NeedsValidation() override
     {
         return true;
     }
 
     //------------------------------------------------------------------
     /// Return true if external variables in the expression should be
     /// resolved.
     //------------------------------------------------------------------
     bool
-    NeedsVariableResolution ()
+    NeedsVariableResolution() override
     {
         return true;
     }
 
     //------------------------------------------------------------------
     /// Evaluate one expression and return its result.
     ///
     /// @param[in] exe_ctx
private:
 
     bool                                        m_can_interpret;        ///< True if the expression could be evaluated statically; false otherwise.
     lldb::addr_t                                m_materialized_address; ///< The address at which the arguments to the expression have been materialized.
     Materializer::DematerializerSP              m_dematerializer_sp;    ///< The dematerializer.
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ClangUserExpression_h_
+#endif // liblldb_ClangUserExpression_h_

lldb/trunk/include/lldb/Expression/ClangUtilityFunction.h

public:
     ///     The text of the function.  Must be a full translation unit.
     ///
     /// @param[in] name
     ///     The name of the function, as used in the text.
     //------------------------------------------------------------------
     ClangUtilityFunction (const char *text, 
                           const char *name);
     
-    virtual 
-    ~ClangUtilityFunction ();
+    ~ClangUtilityFunction() override;
 
     //------------------------------------------------------------------
     /// Install the utility function into a process
     ///
     /// @param[in] error_stream
     ///     A stream to print parse errors and warnings to.
     ///
     /// @param[in] exe_ctx
public:
     }
     
     
     //------------------------------------------------------------------
     /// Return the string that the parser should parse.  Must be a full
     /// translation unit.
     //------------------------------------------------------------------
     const char *
-    Text ()
+    Text() override
     {
         return m_function_text.c_str();
     }
     
     //------------------------------------------------------------------
     /// Return the function name that should be used for executing the
     /// expression.  Text() should contain the definition of this
     /// function.
     //------------------------------------------------------------------
     const char *
-    FunctionName ()
+    FunctionName() override
     {
         return m_function_name.c_str();
     }
     
     //------------------------------------------------------------------
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     //------------------------------------------------------------------
     ClangExpressionDeclMap *
-    DeclMap ()
+    DeclMap() override
     {
         return m_expr_decl_map.get();
     }
     
     //------------------------------------------------------------------
     /// Return the object that the parser should use when registering
     /// local variables.  May be NULL if the Expression doesn't care.
     //------------------------------------------------------------------
     ClangExpressionVariableList *
     LocalVariables ()
     {
         return NULL;
     }
     
     //------------------------------------------------------------------
     /// Return the object that the parser should allow to access ASTs.
     /// May be NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
     ///     the ASTs to after transformation.
     //------------------------------------------------------------------
     clang::ASTConsumer *
-    ASTTransformer (clang::ASTConsumer *passthrough)
+    ASTTransformer(clang::ASTConsumer *passthrough) override
     {
         return NULL;
     }
     
     //------------------------------------------------------------------
     /// Return true if validation code should be inserted into the
     /// expression.
     //------------------------------------------------------------------
     bool
-    NeedsValidation ()
+    NeedsValidation() override
     {
         return false;
     }
     
     //------------------------------------------------------------------
     /// Return true if external variables in the expression should be
     /// resolved.
     //------------------------------------------------------------------
     bool
-    NeedsVariableResolution ()
+    NeedsVariableResolution() override
     {
         return false;
     }
     
 private:
     std::unique_ptr<ClangExpressionDeclMap>  m_expr_decl_map;    ///< The map to use when parsing and materializing the expression.
     std::shared_ptr<IRExecutionUnit>         m_execution_unit_sp;
     lldb::ModuleWP                           m_jit_module_wp;
     std::string                              m_function_text;    ///< The text of the function.  Must be a well-formed translation unit.
     std::string                              m_function_name;    ///< The name of the function.
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ClangUtilityFunction_h_
+#endif // liblldb_ClangUtilityFunction_h_

lldb/trunk/include/lldb/Expression/IRDynamicChecks.h

namespace llvm {
     class Constant;
     class Function;
     class Instruction;
     class Module;
     class DataLayout;
     class Value;
 }
 
-namespace lldb_private 
+namespace lldb_private
 {
 
 class ClangExpressionDeclMap;
 class ClangUtilityFunction;
 class ExecutionContext;
 class Stream;
 
 //----------------------------------------------------------------------
public:
     ///     this case, used to find objc_msgSend
     //------------------------------------------------------------------
     IRDynamicChecks (DynamicCheckerFunctions &checker_functions,
                      const char* func_name = "$__lldb_expr");
     
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    virtual ~IRDynamicChecks();
+    ~IRDynamicChecks() override;
     
     //------------------------------------------------------------------
     /// Run this IR transformer on a single module
     ///
     /// @param[in] M
     ///     The module to run on.  This module is searched for the function
     ///     $__lldb_expr, and that function is passed to the passes one by 
     ///     one.
     ///
     /// @return
     ///     True on success; false otherwise
     //------------------------------------------------------------------
-    bool runOnModule(llvm::Module &M);
+    bool runOnModule(llvm::Module &M) override;
     
     //------------------------------------------------------------------
     /// Interface stub
     //------------------------------------------------------------------
     void assignPassManager(llvm::PMStack &PMS,
-                           llvm::PassManagerType T = llvm::PMT_ModulePassManager);
+                           llvm::PassManagerType T = llvm::PMT_ModulePassManager)  override;
     
     //------------------------------------------------------------------
     /// Returns PMT_ModulePassManager
     //------------------------------------------------------------------
-    llvm::PassManagerType getPotentialPassManagerType() const;
+    llvm::PassManagerType getPotentialPassManagerType() const override;
+
 private:
     //------------------------------------------------------------------
     /// A basic block-level pass to find all pointer dereferences and
     /// validate them before use.
     //------------------------------------------------------------------
     
     //------------------------------------------------------------------
     /// The top-level pass implementation
private:
     //------------------------------------------------------------------
     bool FindDataLoads(llvm::Module &M, 
                        llvm::BasicBlock &BB);
     
     std::string                 m_func_name;            ///< The name of the function to add checks to
     DynamicCheckerFunctions    &m_checker_functions;    ///< The checker functions for the process
 };
     
-}
+} // namespace lldb_private
 
-#endif
+#endif // liblldb_IRDynamicChecks_h_

lldb/trunk/include/lldb/Expression/IRExecutionUnit.h

 //===-- IRExecutionUnit.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef lldb_IRExecutionUnit_h_
-#define lldb_IRExecutionUnit_h_
+#ifndef liblldb_IRExecutionUnit_h_
+#define liblldb_IRExecutionUnit_h_
 
 // C Includes
 // C++ Includes
 #include <atomic>
 #include <string>
 #include <vector>
 #include <map>
 
IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap,
                      std::unique_ptr<llvm::Module> &module_ap,
                      ConstString &name,
                      const lldb::TargetSP &target_sp,
                      std::vector<std::string> &cpu_features);
     
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    ~IRExecutionUnit();
+    ~IRExecutionUnit() override;
         
     llvm::Module *
     GetModule()
     {
         return m_module;
     }
     
     llvm::Function *
WriteNow (const uint8_t *bytes,
               Error &error);
     
     void
     FreeNow (lldb::addr_t allocation);
     
     //------------------------------------------------------------------
     /// ObjectFileJITDelegate overrides
     //------------------------------------------------------------------
-    virtual lldb::ByteOrder
-    GetByteOrder () const;
+    lldb::ByteOrder
+    GetByteOrder() const override;
     
-    virtual uint32_t
-    GetAddressByteSize () const;
+    uint32_t
+    GetAddressByteSize() const override;
     
-    virtual void
-    PopulateSymtab (lldb_private::ObjectFile *obj_file,
-                    lldb_private::Symtab &symtab);
+    void
+    PopulateSymtab(lldb_private::ObjectFile *obj_file,
+       lldb_private::Symtab &symtab) override;
     
-    virtual void
-    PopulateSectionList (lldb_private::ObjectFile *obj_file,
-                         lldb_private::SectionList &section_list);
+    void
+    PopulateSectionList(lldb_private::ObjectFile *obj_file,
+      lldb_private::SectionList &section_list) override;
     
-    virtual bool
-    GetArchitecture (lldb_private::ArchSpec &arch);
+    bool
+    GetArchitecture(lldb_private::ArchSpec &arch) override;
     
     lldb::ModuleSP
     GetJITModule ();
     
 private:
     //------------------------------------------------------------------
     /// Look up the object in m_address_map that contains a given address,
     /// find where it was copied to, and return the remote address at the
private:
     void
     ReportSymbolLookupError(const ConstString &name);
 
     class MemoryManager : public llvm::SectionMemoryManager
     {
     public:
         MemoryManager (IRExecutionUnit &parent);
         
-        virtual ~MemoryManager();
+        ~MemoryManager() override;
         
         //------------------------------------------------------------------
         /// Allocate space for executable code, and add it to the
         /// m_spaceBlocks map
         ///
         /// @param[in] Size
         ///     The size of the area.
         ///
         /// @param[in] Alignment
         ///     The required alignment of the area.
         ///
         /// @param[in] SectionID
         ///     A unique identifier for the section.
         ///
         /// @return
         ///     Allocated space.
         //------------------------------------------------------------------
-        virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
-                                             unsigned SectionID,
-                                             llvm::StringRef SectionName);
+        uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
+             unsigned SectionID,
+             llvm::StringRef SectionName) override;
         
         //------------------------------------------------------------------
         /// Allocate space for data, and add it to the m_spaceBlocks map
         ///
         /// @param[in] Size
         ///     The size of the area.
         ///
         /// @param[in] Alignment
         ///     The required alignment of the area.
         ///
         /// @param[in] SectionID
         ///     A unique identifier for the section.
         ///
         /// @param[in] IsReadOnly
         ///     Flag indicating the section is read-only.
         ///
         /// @return
         ///     Allocated space.
         //------------------------------------------------------------------
-        virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
-                                             unsigned SectionID,
-                                             llvm::StringRef SectionName,
-                                             bool IsReadOnly);
+        uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
+             unsigned SectionID,
+             llvm::StringRef SectionName,
+             bool IsReadOnly) override;
         
         //------------------------------------------------------------------
         /// Called when object loading is complete and section page
         /// permissions can be applied. Currently unimplemented for LLDB.
         ///
         /// @param[out] ErrMsg
         ///     The error that prevented the page protection from succeeding.
         ///
         /// @return
         ///     True in case of failure, false in case of success.
         //------------------------------------------------------------------
-        virtual bool finalizeMemory(std::string *ErrMsg) {
+        bool finalizeMemory(std::string *ErrMsg) override {
             // TODO: Ensure that the instruction cache is flushed because
             // relocations are updated by dy-load.  See:
             //   sys::Memory::InvalidateInstructionCache
             //   llvm::SectionMemoryManager
             return false;
         }
         
-        virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) {
-            return;
+        void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override {
         }
         
         //------------------------------------------------------------------
         /// Passthrough interface stub
         //------------------------------------------------------------------
-        virtual uint64_t getSymbolAddress(const std::string &Name);
+        uint64_t getSymbolAddress(const std::string &Name) override;
+
+        void *getPointerToNamedFunction(const std::string &Name,
+          bool AbortOnFailure = true) override;
 
-        virtual void *getPointerToNamedFunction(const std::string &Name,
-                                                bool AbortOnFailure = true);
     private:
         std::unique_ptr<SectionMemoryManager>    m_default_mm_ap;    ///< The memory allocator to use in actually creating space.  All calls are passed through to it.
         IRExecutionUnit                    &m_parent;           ///< The execution unit this is a proxy for.
     };
     
     //----------------------------------------------------------------------
     /// @class JittedFunction IRExecutionUnit.h "lldb/Expression/IRExecutionUnit.h"
     /// @brief Encapsulates a single function that has been generated by the JIT.
private:
     std::atomic<bool>                       m_did_jit;
 
     lldb::addr_t                            m_function_load_addr;
     lldb::addr_t                            m_function_end_load_addr;
 };
 
 } // namespace lldb_private
 
-#endif  // lldb_IRExecutionUnit_h_
+#endif // liblldb_IRExecutionUnit_h_

lldb/trunk/include/lldb/Expression/IRForTarget.h

IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map,
                 bool resolve_vars,
                 lldb_private::IRExecutionUnit &execution_unit,
                 lldb_private::Stream *error_stream,
                 const char* func_name = "$__lldb_expr");
     
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
-    virtual ~IRForTarget();
+    ~IRForTarget() override;
     
     //------------------------------------------------------------------
     /// Run this IR transformer on a single module
     ///
     /// Implementation of the llvm::ModulePass::runOnModule() function.
     ///
     /// @param[in] llvm_module
     ///     The module to run on.  This module is searched for the function
     ///     $__lldb_expr, and that function is passed to the passes one by 
     ///     one.
     ///
     /// @param[in] interpreter_error
     ///     An error.  If the expression fails to be interpreted, this error
     ///     is set to a reason why.
     ///
     /// @return
     ///     True on success; false otherwise
     //------------------------------------------------------------------
-    virtual bool 
-    runOnModule (llvm::Module &llvm_module);
+    bool 
+    runOnModule(llvm::Module &llvm_module) override;
     
     //------------------------------------------------------------------
     /// Interface stub
     ///
     /// Implementation of the llvm::ModulePass::assignPassManager() 
     /// function.
     //------------------------------------------------------------------
-    virtual void
-    assignPassManager (llvm::PMStack &pass_mgr_stack,
-                       llvm::PassManagerType pass_mgr_type = llvm::PMT_ModulePassManager);
+    void
+    assignPassManager(llvm::PMStack &pass_mgr_stack,
+          llvm::PassManagerType pass_mgr_type = llvm::PMT_ModulePassManager) override;
     
     //------------------------------------------------------------------
     /// Returns PMT_ModulePassManager
     ///
     /// Implementation of the llvm::ModulePass::getPotentialPassManagerType() 
     /// function.
     //------------------------------------------------------------------
-    virtual llvm::PassManagerType 
-    getPotentialPassManagerType() const;
+    llvm::PassManagerType
+    getPotentialPassManagerType() const override;
 
 private:
     //------------------------------------------------------------------
     /// Ensures that the current function's linkage is set to external.
     /// Otherwise the JIT may not return an address for it.
     ///
     /// @param[in] llvm_function
     ///     The function whose linkage is to be fixed.
private:
     /// @return
     ///     True on success; false otherwise
     //------------------------------------------------------------------
     bool 
     CompleteDataAllocation ();
 
 };
 
-#endif
+#endif // liblldb_IRForTarget_h_

lldb/trunk/include/lldb/Initialization/SystemInitializerCommon.h

 /// functionality is separate.  This class is used by constructing
 /// an instance of SystemLifetimeManager with this class passed to
 /// the constructor.
 //------------------------------------------------------------------
 class SystemInitializerCommon : public SystemInitializer
 {
   public:
     SystemInitializerCommon();
-    virtual ~SystemInitializerCommon();
+    ~SystemInitializerCommon() override;
 
     void Initialize() override;
     void Terminate() override;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // LLDB_INITIALIZATION_SYSTEM_INITIALIZER_COMMON_H