C.128 override, virtual keyword handling

[kkleine]

Summary

According to [C128] "Virtual functions should specify exactly one
of virtual, override, or final", I've added override where a
virtual function is overriden but the explicit override keyword
was missing. Whenever both virtual and override were specified,
I removed virtual. As C.128 puts it:

[...] writing more than one of these three is both redundant and
a potential source of errors.

I anticipate a discussion about whether or not to add override to
destructors but I went for it because of an example in [ISOCPP1000].
Let me repeat the comment for you here:

Consider this code:

struct Base {
  virtual ~Base(){}
};

struct SubClass : Base {
  ~SubClass() {
    std::cout << "It works!\n";
  }
};

int main() {
  std::unique_ptr<Base> ptr = std::make_unique<SubClass>();
}

If for some odd reason somebody removes the virtual keyword from the
Base struct, the code will no longer print It works!. So adding
override to destructors actively protects us from accidentally
breaking our code at runtime.

[C128]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c128-virtual-functions-should-specify-exactly-one-of-virtual-override-or-final
[ISOCPP1000]: https://github.com/isocpp/CppCoreGuidelines/issues/1000#issuecomment-476951555

[shafik]

Thank you! LGTM, in general we avoid "large" refactoring changes to avoid polluting the blame list but the changes are relatively local and they are good changes that can catch real bugs in the future. I would like a second set of eyes though.

[teemperor]

LGTM module some minor code style issues (You removed some virtuals but didn't fix the indentation of the parameters on the next line, see the inline comments for examples).

lldb/include/lldb/Utility/Baton.h

66

code style

lldb/tools/intel-features/intel-mpx/cli-wrapper-mpxtable.cpp

306

code style

351

code style

[kwk]

In D61440#1488174, @teemperor wrote:

LGTM module some minor code style issues (You removed some virtuals but didn't fix the indentation of the parameters on the next line, see the inline comments for examples).

@teemperor I would have loved to use clang-format for this but apparently the LLDB code is still manually formatted. It would be a bliss to just use the LLVM clang-format style and never ever talk about "style" again.

[kkleine]

• Fix https://reviews.llvm.org/D61440#inline-545102
• Fix https://reviews.llvm.org/D61440#inline-545098
• Fix https://reviews.llvm.org/D61440#inline-545099

[kwk]

@teemperor I've addressed your requests for style changes. As it turns out, clang-format did indeed change nothing else in those files. I wonder if I can turn it on everywhere without polluting the history with formatting commits. Thank you for pointing out those style issues. This is one of the first changes I've done to LLDB and I'm very happy that you and @shafik like the change.

[teemperor]

In D61440#1488424, @kwk wrote:

In D61440#1488174, @teemperor wrote:

LGTM module some minor code style issues (You removed some virtuals but didn't fix the indentation of the parameters on the next line, see the inline comments for examples).

@teemperor I would have loved to use clang-format for this but apparently the LLDB code is still manually formatted. It would be a bliss to just use the LLVM clang-format style and never ever talk about "style" again.

I assume you mean running clang-format manually on each file? If yes, then check out git-clang-format which works just fine in these situations.

[teemperor]

FYI, I still think there are some style issues there (e.g. the AppleObjCRuntimeV2.cpp change makes it longer than 80 chars) but I can just clang-format this before committing.

Otherwise, unless someone objects to this change I'll merge this tomorrow. Thanks for the patch @kkleine!

[kkleine]

• Address formatting issues brought up in https://reviews.llvm.org/D61440#1488450

[kwk]

In D61440#1488450, @teemperor wrote:

FYI, I still think there are some style issues there (e.g. the AppleObjCRuntimeV2.cpp change makes it longer than 80 chars) but I can just clang-format this before committing.

Otherwise, unless someone objects to this change I'll merge this tomorrow. Thanks for the patch @kkleine!

@teemperor I've formatted the AppleObjCRuntimeV2.cpp using git clang-format and it worked. Thank you for pointing me this handy tool. But as you probably can see now in commit 0b4b24065a12678c773f8c3f0fc722e50405fc85, not all the changes were related to the override keyword.

[teemperor]

Not sure how you invoke git clang-format, but I assume you specified the wrong commit range...

I personally use some custom command that executes this git rebase -i --autosquash -x 'git clang-format master && git commit -a --amend --no-edit' master which essentially clang-formats all your git commits (i.e. the ones that are in the local branch but not in master). So if you have the original version of this diff as its own git commit on a separate branch then this command should do all the work for you.

[kwk]

In D61440#1488470, @teemperor wrote:

Not sure how you invoke git clang-format, but I assume you specified the wrong commit range...

That is correct in this case I've used clang format directly on the whole file. Sorry if that was a noob mistake.

I personally use some custom command that executes this git rebase -i --autosquash -x 'git clang-format master && git commit -a --amend --no-edit' master which essentially clang-formats all your git commits (i.e. the ones that are in the local branch but not in master). So if you have the original version of this diff as its own git commit on a separate branch then this command should do all the work for you.

Thank you for that tip. Unfortunately I've started not on a branch and when I create it now things become complicated. I'm not famiiar enough with the arc tool and will do some reading before just calling arc diff next time. Because when I do that now after rebasing, arc tries to upload a commit that is no longer in my history.

How do you handle rebasing or squashing here? When I run your special command from above, it will rewrite the git history which to me is a no go when I send my code to review. If all these reviews are going to happen on Github anytime, then you would embrace having an append-only history.

[teemperor]

You don't have to use arc, you can also just update the code via the "Update diff" button and upload a patch file. So it doesn't really matter how you organize your local git branch as long as you can produce a patch file from the changes. Phabricator takes care of making diffs between the patches you upload, so there is always a change history here.

[kkleine]

• Address formatting issues brought up in https://reviews.llvm.org/D61440#1488450

[kwk]

@teemperor I've squashed my commits without the last one that did those many changes in the file lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp. I hope at least the result is fine now.

[teemperor]

Looks good now, thanks!

[kwk]

In D61440#1489064, @teemperor wrote:

Looks good now, thanks!

Thank you for being patient with me! Can you merge the change for me please? I don't have commit rights, yet.

lldb/include/lldb/Core/Architecture.h

 
 #include "lldb/Core/PluginInterface.h"
 
 namespace lldb_private {
 
 class Architecture : public PluginInterface {
 public:
   Architecture() = default;
-  virtual ~Architecture() = default;
+  ~Architecture() override = default;
 
   /// This is currently intended to handle cases where a
   /// program stops at an instruction that won't get executed and it
   /// allows the stop reason, like "breakpoint hit", to be replaced
   /// with a different stop reason like "no stop reason".
   ///
   /// This is specifically used for ARM in Thumb code when we stop in
   /// an IT instruction (if/then/else) where the instruction won't get

lldb/include/lldb/Core/StreamBuffer.h

 
 template <unsigned N> class StreamBuffer : public Stream {
 public:
   StreamBuffer() : Stream(0, 4, lldb::eByteOrderBig), m_packet() {}
 
   StreamBuffer(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order)
       : Stream(flags, addr_size, byte_order), m_packet() {}
 
-  virtual ~StreamBuffer() {}
+  ~StreamBuffer() override {}
 
-  virtual void Flush() {
+  void Flush() override {
     // Nothing to do when flushing a buffer based stream...
   }
 
   void Clear() { m_packet.clear(); }
 
   // Beware, this might not be NULL terminated as you can expect from
   // StringString as there may be random bits in the llvm::SmallVector. If you
   // are using this class to create a C string, be sure the call PutChar ('\0')
   // after you have created your string, or use StreamString.
   const char *GetData() const { return m_packet.data(); }
 
   size_t GetSize() const { return m_packet.size(); }
 
 protected:
   llvm::SmallVector<char, N> m_packet;
 
-  virtual size_t WriteImpl(const void *s, size_t length) {
+  size_t WriteImpl(const void *s, size_t length) override {
     if (s && length)
       m_packet.append((const char *)s, ((const char *)s) + length);
     return length;
   }
 };
 
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_StreamBuffer_h_

lldb/include/lldb/Core/ValueObjectVariable.h

public:
   bool GetDeclaration(Declaration &decl) override;
 
   const char *GetLocationAsCString() override;
 
   bool SetValueFromCString(const char *value_str, Status &error) override;
 
   bool SetData(DataExtractor &data, Status &error) override;
 
-  virtual lldb::VariableSP GetVariable() override { return m_variable_sp; }
+  lldb::VariableSP GetVariable() override { return m_variable_sp; }
 
 protected:
   bool UpdateValue() override;
 
   CompilerType GetCompilerTypeImpl() override;
 
   lldb::VariableSP
       m_variable_sp;      ///< The variable that this value object is based upon

lldb/include/lldb/Target/DynamicLoader.h

public:
 
   /// Construct with a process.
   DynamicLoader(Process *process);
 
   /// Destructor.
   ///
   /// The destructor is virtual since this class is designed to be inherited
   /// from by the plug-in instance.
-  virtual ~DynamicLoader() override;
+  ~DynamicLoader() override;
 
   /// Called after attaching a process.
   ///
   /// Allow DynamicLoader plug-ins to execute some code after attaching to a
   /// process.
   virtual void DidAttach() = 0;
 
   /// Called after launching a process.

lldb/include/lldb/Target/StackFrameRecognizer.h

 class ScriptedStackFrameRecognizer : public StackFrameRecognizer {
   lldb_private::ScriptInterpreter *m_interpreter;
   lldb_private::StructuredData::ObjectSP m_python_object_sp;
   std::string m_python_class;
 
 public:
   ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter,
                                const char *pclass);
-  ~ScriptedStackFrameRecognizer() {}
+  ~ScriptedStackFrameRecognizer() override {}
 
   std::string GetName() override {
     return GetPythonClassName();
   }
 
   const char *GetPythonClassName() { return m_python_class.c_str(); }
 
   lldb::RecognizedStackFrameSP RecognizeFrame(

lldb/include/lldb/Target/StructuredDataPlugin.h

 /// and error streams such that the plugin can display something about the
 /// event, at a time when the debugger ensures it is safe to write to the
 /// output or error streams.
 
 class StructuredDataPlugin
     : public PluginInterface,
       public std::enable_shared_from_this<StructuredDataPlugin> {
 public:
-  virtual ~StructuredDataPlugin();
+  ~StructuredDataPlugin() override;
 
   lldb::ProcessSP GetProcess() const;
 
   // Public instance API
 
   /// Return whether this plugin supports the given StructuredData feature.
   ///
   /// When Process is informed of a list of process-monitor-supported

lldb/include/lldb/Utility/Baton.h

public:
 
   virtual void GetDescription(Stream *s,
                               lldb::DescriptionLevel level) const = 0;
 };
 
 class UntypedBaton : public Baton {
 public:
   UntypedBaton(void *Data) : m_data(Data) {}
-  virtual ~UntypedBaton() {
+  ~UntypedBaton() override {
     // The default destructor for an untyped baton does NOT attempt to clean up
     // anything in m_data.
   }
 
   void *data() override { return m_data; }
   void GetDescription(Stream *s, lldb::DescriptionLevel level) const override;
 
   void *m_data; // Leave baton public for easy access
 };
 
 template <typename T> class TypedBaton : public Baton {
 public:
   explicit TypedBaton(std::unique_ptr<T> Item) : Item(std::move(Item)) {}
 
   T *getItem() { return Item.get(); }
   const T *getItem() const { return Item.get(); }
 
   void *data() override { return Item.get(); }
-  virtual void GetDescription(Stream *s,
-                              lldb::DescriptionLevel level) const override {}
+  void GetDescription(Stream *s, lldb::DescriptionLevel level) const override {}
 
 protected:
   std::unique_ptr<T> Item;
 };
 
 } // namespace lldb_private
 
 #endif // lldb_Baton_h_

lldb/include/lldb/Utility/DataBufferLLVM.h

 class Twine;
 }
 
 namespace lldb_private {
 
 class FileSystem;
 class DataBufferLLVM : public DataBuffer {
 public:
-  ~DataBufferLLVM();
+  ~DataBufferLLVM() override;
 
   uint8_t *GetBytes() override;
   const uint8_t *GetBytes() const override;
   lldb::offset_t GetByteSize() const override;
 
   char *GetChars() { return reinterpret_cast<char *>(GetBytes()); }
 
 private:

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

StringExtractorGDBRemote(llvm::StringRef str)
       : StringExtractor(str), m_validator(nullptr) {}
 
   StringExtractorGDBRemote(const char *cstr)
       : StringExtractor(cstr), m_validator(nullptr) {}
 
   StringExtractorGDBRemote(const StringExtractorGDBRemote &rhs)
       : StringExtractor(rhs), m_validator(rhs.m_validator) {}
 
-  virtual ~StringExtractorGDBRemote() {}
+  ~StringExtractorGDBRemote() override {}
 
   bool ValidateResponse() const;
 
   void CopyResponseValidator(const StringExtractorGDBRemote &rhs);
 
   void SetResponseValidator(ResponseValidatorCallback callback, void *baton);
 
   void SetResponseValidatorToOKErrorNotSupported();

lldb/source/API/SBBreakpointOptionCommon.h

struct CallbackData {
   void *callback_baton;
 };
 
 class SBBreakpointCallbackBaton : public lldb_private::TypedBaton<CallbackData> {
 public:
   SBBreakpointCallbackBaton(SBBreakpointHitCallback callback,
                             void *baton);
 
-  ~SBBreakpointCallbackBaton();
+  ~SBBreakpointCallbackBaton() override;
 
   static bool PrivateBreakpointHitCallback(void *baton,
                                            lldb_private::StoppointCallbackContext *ctx,
                                            lldb::user_id_t break_id,
                                            lldb::user_id_t break_loc_id);
 };
 
 } // namespace lldb
 #endif // LLDB_SBBreakpointOptionCommons_h_

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

static ConstString &GetSettingName() {
     return g_setting_name;
   }
 
   DynamicLoaderDarwinKernelProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
-  virtual ~DynamicLoaderDarwinKernelProperties() {}
+  ~DynamicLoaderDarwinKernelProperties() override {}
 
   bool GetLoadKexts() const {
     const uint32_t idx = ePropertyLoadKexts;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(
         NULL, idx, g_properties[idx].default_uint_value != 0);
   }
 
   KASLRScanType GetScanType() const {

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h

 #include "llvm/ADT/Triple.h"
 
 namespace lldb_private {
 
 class DynamicLoaderDarwin : public lldb_private::DynamicLoader {
 public:
   DynamicLoaderDarwin(lldb_private::Process *process);
 
-  virtual ~DynamicLoaderDarwin() override;
+  ~DynamicLoaderDarwin() override;
 
   /// Called after attaching a process.
   ///
   /// Allow DynamicLoader plug-ins to execute some code after
   /// attaching to a process.
   void DidAttach() override;
 
   void DidLaunch() override;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h

 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
 class DynamicLoaderMacOS : public lldb_private::DynamicLoaderDarwin {
 public:
   DynamicLoaderMacOS(lldb_private::Process *process);
 
-  virtual ~DynamicLoaderMacOS() override;
+  ~DynamicLoaderMacOS() override;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
 class DynamicLoaderMacOSXDYLD : public lldb_private::DynamicLoaderDarwin {
 public:
   DynamicLoaderMacOSXDYLD(lldb_private::Process *process);
 
-  virtual ~DynamicLoaderMacOSXDYLD() override;
+  ~DynamicLoaderMacOSXDYLD() override;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 

lldb/source/Plugins/ExpressionParser/Clang/ClangDiagnostic.h

public:
   static inline bool classof(const Diagnostic *diag) {
     return diag->getKind() == eDiagnosticOriginClang;
   }
 
   ClangDiagnostic(const char *message, DiagnosticSeverity severity,
                   uint32_t compiler_id)
       : Diagnostic(message, severity, eDiagnosticOriginClang, compiler_id) {}
 
-  virtual ~ClangDiagnostic() = default;
+  ~ClangDiagnostic() override = default;
 
   bool HasFixIts() const override { return !m_fixit_vec.empty(); }
 
   void AddFixitHint(const clang::FixItHint &fixit) {
     m_fixit_vec.push_back(fixit);
   }
 
   const FixItList &FixIts() const { return m_fixit_vec; }
   FixItList m_fixit_vec;
 };
 
 } // namespace lldb_private
 #endif /* lldb_ClangDiagnostic_h */

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

ClangDiagnosticManagerAdapter(
       const std::shared_ptr<clang::TextDiagnosticBuffer> &passthrough)
       : m_passthrough(passthrough) {}
 
   void ResetManager(DiagnosticManager *manager = nullptr) {
     m_manager = manager;
   }
 
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                        const clang::Diagnostic &Info) {
+                        const clang::Diagnostic &Info) override {
     if (m_manager) {
       llvm::SmallVector<char, 32> diag_str;
       Info.FormatDiagnostic(diag_str);
       diag_str.push_back('\0');
       const char *data = diag_str.data();
 
       lldb_private::DiagnosticSeverity severity;
       bool make_new_diagnostic = true;
CodeComplete(CompletionRequest &request, clang::LangOptions ops,
     m_desc_policy.FullyQualifiedName = false;
     m_desc_policy.TerseOutput = true;
     m_desc_policy.IncludeNewlines = false;
     m_desc_policy.UseVoidForZeroParams = false;
     m_desc_policy.Bool = true;
   }
 
   /// Deregisters and destroys this code-completion consumer.
-  virtual ~CodeComplete() {}
+  ~CodeComplete() override {}
 
   /// \name Code-completion filtering
   /// Check if the result should be filtered out.
   bool isResultFilteredOut(StringRef Filter,
                            CodeCompletionResult Result) override {
     // This code is mostly copied from CodeCompleteConsumer.
     switch (Result.Kind) {
     case CodeCompletionResult::RK_Declaration:

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
       "unichar summary provider", ConstString("unichar"), widechar_flags);
 }
 
 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
   class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
   public:
-    virtual CompilerType AdjustForInclusion(CompilerType &candidate) override {
+    CompilerType AdjustForInclusion(CompilerType &candidate) override {
       LanguageType lang_type(candidate.GetMinimumLanguage());
       if (!Language::LanguageIsC(lang_type) &&
           !Language::LanguageIsCPlusPlus(lang_type))
         return CompilerType();
       if (candidate.IsTypedefType())
         return candidate.GetTypedefedType();
       return candidate;
     }

lldb/source/Plugins/Language/ObjC/NSDictionary.h

public:
       virtual ~Matcher() = default;
       virtual bool Match(ConstString class_name) = 0;
 
       typedef std::unique_ptr<Matcher> UP;
     };
     class Prefix : public Matcher {
     public:
       Prefix(ConstString p);
-      virtual ~Prefix() = default;
-      virtual bool Match(ConstString class_name) override;
+      ~Prefix() override = default;
+      bool Match(ConstString class_name) override;
 
     private:
       ConstString m_prefix;
     };
     class Full : public Matcher {
     public:
       Full(ConstString n);
-      virtual ~Full() = default;
-      virtual bool Match(ConstString class_name) override;
+      ~Full() override = default;
+      bool Match(ConstString class_name) override;
 
     private:
       ConstString m_name;
     };
     typedef Matcher::UP MatcherUP;
 
     MatcherUP GetFullMatch(ConstString n) { return llvm::make_unique<Full>(n); }
 

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
       return result;
     }
 
     friend class lldb_private::ObjCLanguage;
   };
   
   class ObjCDebugInfoScavenger : public Language::ImageListTypeScavenger {
   public:
-    virtual CompilerType AdjustForInclusion(CompilerType &candidate) override {
+    CompilerType AdjustForInclusion(CompilerType &candidate) override {
       LanguageType lang_type(candidate.GetMinimumLanguage());
       if (!Language::LanguageIsObjC(lang_type))
         return CompilerType();
       if (candidate.IsTypedefType())
         return candidate.GetTypedefedType();
       return candidate;
     }
   };

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
       return new AppleObjCRuntimeV2(process, objc_module_sp);
     else
       return NULL;
   } else
     return NULL;
 }
 
 static constexpr OptionDefinition g_objc_classtable_dump_options[] = {
-    {LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument,
-     nullptr, {}, 0, eArgTypeNone,
+    {LLDB_OPT_SET_ALL,
+     false,
+     "verbose",
+     'v',
+     OptionParser::eNoArgument,
+     nullptr,
+     {},
+     0,
+     eArgTypeNone,
      "Print ivar and method information in detail"}};
 
 class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_verbose(false, false) {}
 
public:
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_objc_classtable_dump_options);
     }
 
     OptionValueBoolean m_verbose;
   };
 
   CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter)
-      : CommandObjectParsed(
-            interpreter, "dump", "Dump information on Objective-C classes "
-                                 "known to the current process.",
+      : CommandObjectParsed(interpreter, "dump",
+                            "Dump information on Objective-C classes "
                             "language objc class-table dump",
-            eCommandRequiresProcess | eCommandProcessMustBeLaunched |
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched |
                                 eCommandProcessMustBePaused),
         m_options() {
     CommandArgumentEntry arg;
     CommandArgumentData index_arg;
 
     // Define the first (and only) variant of this arg.
     index_arg.arg_type = eArgTypeRegularExpression;
     index_arg.arg_repetition = eArgRepeatOptional;
 
len = ::snprintf(check_function_code, sizeof(check_function_code), R"(
                          *((volatile int *)0) = 'ocgc';
                        } else if ($__lldb_arg_selector != (void *)0) {
                          signed char $responds = (signed char)
                              [(id)$__lldb_arg_obj respondsToSelector:
                                  (void *) $__lldb_arg_selector];
                          if ($responds == (signed char) 0)
                            *((volatile int *)0) = 'ocgc';
                        }
-                     })", name);
+                     })",
+                     name);
   } else {
     len = ::snprintf(check_function_code, sizeof(check_function_code), R"(
                      extern "C" void *gdb_class_getClass(void *);
                      extern "C" int printf(const char *format, ...);
                      extern "C" void
                      %s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) {
                        if ($__lldb_arg_obj == (void *)0)
                          return; // nil is ok
                        void **$isa_ptr = (void **)$__lldb_arg_obj;
                        if (*$isa_ptr == (void *)0 ||
                            !gdb_class_getClass(*$isa_ptr))
                          *((volatile int *)0) = 'ocgc';
                        else if ($__lldb_arg_selector != (void *)0) {
                          signed char $responds = (signed char)
                              [(id)$__lldb_arg_obj respondsToSelector:
                                  (void *) $__lldb_arg_selector];
                          if ($responds == (signed char) 0)
                            *((volatile int *)0) = 'ocgc';
                        }
-                     })", name);
+                     })",
+                     name);
   }
 
   assert(len < (int)sizeof(check_function_code));
   UNUSED_IF_ASSERT_DISABLED(len);
 
   Status error;
   return GetTargetRef().GetUtilityFunctionForLanguage(
       check_function_code, eLanguageTypeObjC, name, error);
AppleObjCRuntimeV2::GetClassDescriptor(ValueObject &valobj) {
   }
   return objc_class_sp;
 }
 
 lldb::addr_t AppleObjCRuntimeV2::GetTaggedPointerObfuscator() {
   if (m_tagged_pointer_obfuscator != LLDB_INVALID_ADDRESS)
     return m_tagged_pointer_obfuscator;
 
-
   Process *process = GetProcess();
   ModuleSP objc_module_sp(GetObjCModule());
 
   if (!objc_module_sp)
     return LLDB_INVALID_ADDRESS;
 
-  static ConstString g_gdb_objc_obfuscator("objc_debug_taggedpointer_obfuscator");
+  static ConstString g_gdb_objc_obfuscator(
+      "objc_debug_taggedpointer_obfuscator");
 
   const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
       g_gdb_objc_obfuscator, lldb::eSymbolTypeAny);
   if (symbol) {
     lldb::addr_t g_gdb_obj_obfuscator_ptr =
         symbol->GetLoadAddress(&process->GetTarget());
 
     if (g_gdb_obj_obfuscator_ptr != LLDB_INVALID_ADDRESS) {
       Status error;
-      m_tagged_pointer_obfuscator = process->ReadPointerFromMemory(
-        g_gdb_obj_obfuscator_ptr, error);
+      m_tagged_pointer_obfuscator =
+          process->ReadPointerFromMemory(g_gdb_obj_obfuscator_ptr, error);
     }
   }
-  // If we don't have a correct value at this point, there must be no obfuscation.
+  // If we don't have a correct value at this point, there must be no
+  // obfuscation.
   if (m_tagged_pointer_obfuscator == LLDB_INVALID_ADDRESS)
     m_tagged_pointer_obfuscator = 0;
 
   return m_tagged_pointer_obfuscator;
 }
 
 lldb::addr_t AppleObjCRuntimeV2::GetISAHashTablePointer() {
   if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS) {
AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic(
   }
 
   std::lock_guard<std::mutex> guard(m_get_class_info_args_mutex);
 
   // Fill in our function argument values
   arguments.GetValueAtIndex(0)->GetScalar() = hash_table.GetTableLoadAddress();
   arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
   arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
-  
   // Only dump the runtime classes from the expression evaluation if the log is
   // verbose:
   Log *type_log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES);
   bool dump_log = type_log && type_log->GetVerbose();
-  
   arguments.GetValueAtIndex(3)->GetScalar() = dump_log ? 1 : 0;
 
   bool success = false;
 
   diagnostics.Clear();
 
   // Write our function arguments into the process so we can run our function
   if (get_class_info_function->WriteFunctionArguments(
AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache() {
   // Fill in our function argument values
   arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr;
   arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
   arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
   // Only dump the runtime classes from the expression evaluation if the log is
   // verbose:
   Log *type_log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES);
   bool dump_log = type_log && type_log->GetVerbose();
-  
   arguments.GetValueAtIndex(3)->GetScalar() = dump_log ? 1 : 0;
 
   bool success = false;
 
   diagnostics.Clear();
 
   // Write our function arguments into the process so we can run our function
   if (get_shared_cache_class_info_function->WriteFunctionArguments(
if (name_strref.startswith(ivar_prefix)) {
         const ConstString class_name_cs(class_and_ivar.first);
         ClassDescriptorSP descriptor =
             ObjCLanguageRuntime::GetClassDescriptorFromClassName(class_name_cs);
 
         if (descriptor) {
           const ConstString ivar_name_cs(class_and_ivar.second);
           const char *ivar_name_cstr = ivar_name_cs.AsCString();
 
-          auto ivar_func = [&ret, ivar_name_cstr](
-              const char *name, const char *type, lldb::addr_t offset_addr,
+          auto ivar_func = [&ret,
+                            ivar_name_cstr](const char *name, const char *type,
+                                            lldb::addr_t offset_addr,
                                             uint64_t size) -> lldb::addr_t {
             if (!strcmp(name, ivar_name_cstr)) {
               ret = offset_addr;
               return true;
             }
             return false;
           };
 
           descriptor->Describe(
if (error.Fail() || slot_data == 0 ||
       return nullptr;
     actual_class_descriptor_sp =
         m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
     if (!actual_class_descriptor_sp)
       return ObjCLanguageRuntime::ClassDescriptorSP();
     m_ext_cache[slot] = actual_class_descriptor_sp;
   }
 
-  data_payload =
-      (((uint64_t)unobfuscated << m_objc_debug_taggedpointer_ext_payload_lshift) >>
+  data_payload = (((uint64_t)unobfuscated
+                   << m_objc_debug_taggedpointer_ext_payload_lshift) >>
                   m_objc_debug_taggedpointer_ext_payload_rshift);
 
   return ClassDescriptorSP(
       new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload));
 }
 
 AppleObjCRuntimeV2::NonPointerISACache::NonPointerISACache(
     AppleObjCRuntimeV2 &runtime, const ModuleSP &objc_module_sp,
     uint64_t objc_debug_isa_class_mask, uint64_t objc_debug_isa_magic_mask,
if (GetCFBooleanValuesIfNeeded()) {
     cf_false = m_CFBoolean_values->first;
   } else
     this->AppleObjCRuntime::GetValuesForGlobalCFBooleans(cf_true, cf_false);
 }
 
 #pragma mark Frame recognizers
 
 class ObjCExceptionRecognizedStackFrame : public RecognizedStackFrame {
- public:
   ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
     ThreadSP thread_sp = frame_sp->GetThread();
     ProcessSP process_sp = thread_sp->GetProcess();
 
     const lldb::ABISP &abi = process_sp->GetABI();
-    if (!abi) return;
+    if (!abi)
+      return;
 
     CompilerType voidstar = process_sp->GetTarget()
                                 .GetScratchClangASTContext()
                                 ->GetBasicType(lldb::eBasicTypeVoid)
                                 .GetPointerType();
 
     ValueList args;
     Value input_value;
     input_value.SetCompilerType(voidstar);
     args.PushValue(input_value);
 
-    if (!abi->GetArgumentValues(*thread_sp, args)) return;
+    if (!abi->GetArgumentValues(*thread_sp, args))
+      return;
 
     addr_t exception_addr = args.GetValueAtIndex(0)->GetScalar().ULongLong();
 
     Value value(exception_addr);
     value.SetCompilerType(voidstar);
     exception = ValueObjectConstResult::Create(frame_sp.get(), value,
                                                ConstString("exception"));
     exception = ValueObjectRecognizerSynthesizedValue::Create(
         *exception, eValueTypeVariableArgument);
     exception = exception->GetDynamicValue(eDynamicDontRunTarget);
-      
     m_arguments = ValueObjectListSP(new ValueObjectList());
     m_arguments->Append(exception);
   }
 
   ValueObjectSP exception;
 
   lldb::ValueObjectSP GetExceptionObject() override { return exception; }
 };
 
 class ObjCExceptionThrowFrameRecognizer : public StackFrameRecognizer {
-  lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame) {
+  lldb::RecognizedStackFrameSP
+  RecognizeFrame(lldb::StackFrameSP frame) override {
     return lldb::RecognizedStackFrameSP(
         new ObjCExceptionRecognizedStackFrame(frame));
   };
 };
 
 static void RegisterObjCExceptionRecognizer() {
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
     FileSpec module;
     ConstString function;
     std::tie(module, function) = AppleObjCRuntime::GetExceptionThrowLocation();
     StackFrameRecognizerManager::AddRecognizer(
         StackFrameRecognizerSP(new ObjCExceptionThrowFrameRecognizer()),
         module.GetFilename(), function, /*first_instruction_only*/ true);
   });
 }

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h

 // expression's DWARF language is eLanguageTypeExtRenderscript
 
 class RenderScriptRuntimeModulePass : public llvm::ModulePass {
 public:
   static char ID;
   RenderScriptRuntimeModulePass(const lldb_private::Process *process)
       : ModulePass(ID), m_process_ptr(process) {}
 
-  bool runOnModule(llvm::Module &module);
+  bool runOnModule(llvm::Module &module) override;
 
 private:
   const lldb_private::Process *m_process_ptr;
 };
 
 namespace lldb_private {
 namespace lldb_renderscript {
 struct RSIRPasses : public lldb_private::LLVMUserExpression::IRPasses {
   RSIRPasses(lldb_private::Process *process);
 
   ~RSIRPasses();
 };
 } // namespace lldb_renderscript
 } // namespace lldb_private
 #endif

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

public:
   void Dump(lldb_private::Stream *s) override;
 
   lldb_private::ArchSpec GetArchitecture() override;
 
   lldb_private::UUID GetUUID() override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
-  virtual lldb_private::Address GetEntryPointAddress() override;
+  lldb_private::Address GetEntryPointAddress() override;
 
   lldb_private::Address GetBaseAddress() override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
   // PluginInterface protocol

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

public:
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic();
 
   static const char *GetDescriptionStatic();
 
   PlatformRemoteGDBServer();
 
-  virtual ~PlatformRemoteGDBServer();
+  ~PlatformRemoteGDBServer() override;
 
   // lldb_private::PluginInterface functions
   ConstString GetPluginName() override { return GetPluginNameStatic(); }
 
   uint32_t GetPluginVersion() override { return 1; }
 
   // lldb_private::Platform functions
   Status

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

static ConstString GetSettingName() {
     return ProcessGDBRemote::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
-  virtual ~PluginProperties() {}
+  ~PluginProperties() override {}
 
   uint64_t GetPacketTimeout() {
     const uint32_t idx = ePropertyPacketTimeout;
     return m_collection_sp->GetPropertyAtIndexAsUInt64(
         NULL, idx, g_properties[idx].default_uint_value);
   }
 
   bool SetPacketTimeout(uint64_t timeout) {
CommandObjectProcessGDBRemoteSpeedTest(CommandInterpreter &interpreter)
                "Print the output as JSON data for easy parsing.", false, true) {
     m_option_group.Append(&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
-  ~CommandObjectProcessGDBRemoteSpeedTest() {}
+  ~CommandObjectProcessGDBRemoteSpeedTest() override {}
 
   Options *GetOptions() override { return &m_option_group; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       ProcessGDBRemote *process =
           (ProcessGDBRemote *)m_interpreter.GetExecutionContext()

 
 class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed {
 private:
 public:
   CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process plugin packet history",
                             "Dumps the packet history buffer. ", NULL) {}
 
-  ~CommandObjectProcessGDBRemotePacketHistory() {}
+  ~CommandObjectProcessGDBRemotePacketHistory() override {}
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       ProcessGDBRemote *process =
           (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
               .GetProcessPtr();
       if (process) {

 private:
 public:
   CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "process plugin packet xfer-size",
             "Maximum size that lldb will try to read/write one one chunk.",
             NULL) {}
 
-  ~CommandObjectProcessGDBRemotePacketXferSize() {}
+  ~CommandObjectProcessGDBRemotePacketXferSize() override {}
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       result.AppendErrorWithFormat("'%s' takes an argument to specify the max "
                                    "amount to be transferred when "
                                    "reading/writing",
                                    m_cmd_name.c_str());
CommandObjectProcessGDBRemotePacketSend(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process plugin packet send",
                             "Send a custom packet through the GDB remote "
                             "protocol and print the answer. "
                             "The packet header and footer will automatically "
                             "be added to the packet prior to sending and "
                             "stripped from the result.",
                             NULL) {}
 
-  ~CommandObjectProcessGDBRemotePacketSend() {}
+  ~CommandObjectProcessGDBRemotePacketSend() override {}
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       result.AppendErrorWithFormat(
           "'%s' takes a one or more packet content arguments",
           m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
public:
   CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "process plugin packet monitor",
                          "Send a qRcmd packet through the GDB remote protocol "
                          "and print the response."
                          "The argument passed to this command will be hex "
                          "encoded into a valid 'qRcmd' packet, sent and the "
                          "response will be printed.") {}
 
-  ~CommandObjectProcessGDBRemotePacketMonitor() {}
+  ~CommandObjectProcessGDBRemotePacketMonitor() override {}
 
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     if (command.empty()) {
       result.AppendErrorWithFormat("'%s' takes a command string argument",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
LoadSubCommand(
         "xfer-size",
         CommandObjectSP(
             new CommandObjectProcessGDBRemotePacketXferSize(interpreter)));
     LoadSubCommand("speed-test",
                    CommandObjectSP(new CommandObjectProcessGDBRemoteSpeedTest(
                        interpreter)));
   }
 
-  ~CommandObjectProcessGDBRemotePacket() {}
+  ~CommandObjectProcessGDBRemotePacket() override {}
 };
 
 class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordProcessGDBRemote(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "process plugin",
             "Commands for operating on a ProcessGDBRemote process.",
             "process plugin <subcommand> [<subcommand-options>]") {
     LoadSubCommand(
         "packet",
         CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter)));
   }
 
-  ~CommandObjectMultiwordProcessGDBRemote() {}
+  ~CommandObjectMultiwordProcessGDBRemote() override {}
 };
 
 CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
   if (!m_command_sp)
     m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>(
         GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

: CommandObjectParsed(interpreter, "process plugin dump",
     APPEND_OPT(m_fb_app_state);
     APPEND_OPT(m_fb_abort);
     APPEND_OPT(m_fb_thread);
     APPEND_OPT(m_fb_logcat);
     APPEND_OPT(m_fb_all);
     m_option_group.Finalize();
   }
 
-  ~CommandObjectProcessMinidumpDump() {}
+  ~CommandObjectProcessMinidumpDump() override {}
 
   Options *GetOptions() override { return &m_option_group; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc > 0) {
       result.AppendErrorWithFormat("'%s' take no arguments, only options",
                                    m_cmd_name.c_str());
public:
   CommandObjectMultiwordProcessMinidump(CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "process plugin",
           "Commands for operating on a ProcessMinidump process.",
           "process plugin <subcommand> [<subcommand-options>]") {
     LoadSubCommand("dump",
         CommandObjectSP(new CommandObjectProcessMinidumpDump(interpreter)));
   }
 
-  ~CommandObjectMultiwordProcessMinidump() {}
+  ~CommandObjectMultiwordProcessMinidump() override {}
 };
 
 CommandObject *ProcessMinidump::GetPluginCommandObject() {
   if (!m_command_sp)
     m_command_sp = std::make_shared<CommandObjectMultiwordProcessMinidump>(
         GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h

public:
 
   Status GetDescription(const StructuredData::ObjectSP &object_sp,
                         lldb_private::Stream &stream) override;
 
   bool GetEnabled(ConstString type_name) const override;
 
   void ModulesDidLoad(Process &process, ModuleList &module_list) override;
 
-  ~StructuredDataDarwinLog();
+  ~StructuredDataDarwinLog() override;
 
 private:
   // Private constructors
 
   StructuredDataDarwinLog(const lldb::ProcessWP &process_wp);
 
   // Private static methods
 

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

static ConstString &GetSettingName() {
     return g_setting_name;
   }
 
   StructuredDataDarwinLogProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
-  virtual ~StructuredDataDarwinLogProperties() {}
+  ~StructuredDataDarwinLogProperties() override {}
 
   bool GetEnableOnStartup() const {
     const uint32_t idx = ePropertyEnableOnStartup;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(
         nullptr, idx, g_properties[idx].default_uint_value != 0);
   }
 
   llvm::StringRef GetAutoEnableOptions() const {

lldb/source/Symbol/ClangASTContext.cpp

 
 class NullDiagnosticConsumer : public DiagnosticConsumer {
 public:
   NullDiagnosticConsumer() {
     m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
   }
 
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                        const clang::Diagnostic &info) {
+                        const clang::Diagnostic &info) override {
     if (m_log) {
       llvm::SmallVector<char, 32> diag_str(10);
       info.FormatDiagnostic(diag_str);
       diag_str.push_back('\0');
       m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
     }
   }
 

lldb/source/Symbol/PostfixExpression.cpp

 
 class DWARFCodegen : public Visitor<> {
 public:
   DWARFCodegen(Stream &stream) : m_out_stream(stream) {}
 
   using Visitor<>::Dispatch;
 
 private:
-  void Visit(BinaryOpNode &binary, Node *&);
+  void Visit(BinaryOpNode &binary, Node *&) override;
 
-  void Visit(InitialValueNode &val, Node *&);
+  void Visit(InitialValueNode &val, Node *&) override;
 
-  void Visit(IntegerNode &integer, Node *&) {
+  void Visit(IntegerNode &integer, Node *&) override {
     m_out_stream.PutHex8(DW_OP_constu);
     m_out_stream.PutULEB128(integer.GetValue());
     ++m_stack_depth;
   }
 
-  void Visit(RegisterNode &reg, Node *&);
+  void Visit(RegisterNode &reg, Node *&) override;
 
-  void Visit(SymbolNode &symbol, Node *&) {
+  void Visit(SymbolNode &symbol, Node *&) override {
     llvm_unreachable("Symbols should have been resolved by now!");
   }
 
-  void Visit(UnaryOpNode &unary, Node *&);
+  void Visit(UnaryOpNode &unary, Node *&) override;
 
   Stream &m_out_stream;
 
   /// The number keeping track of the evaluation stack depth at any given
   /// moment. Used for implementing InitialValueNodes. We start with
   /// m_stack_depth = 1, assuming that the initial value is already on the
   /// stack. This initial value will be the value of all InitialValueNodes. If
   /// the expression does not contain InitialValueNodes, then m_stack_depth is

lldb/source/Target/StructuredDataPlugin.cpp

 namespace {
 class CommandStructuredData : public CommandObjectMultiword {
 public:
   CommandStructuredData(CommandInterpreter &interpreter)
       : CommandObjectMultiword(interpreter, "structured-data",
                                "Parent for per-plugin structured data commands",
                                "plugin structured-data <plugin>") {}
 
-  ~CommandStructuredData() {}
+  ~CommandStructuredData() override {}
 };
 }
 
 StructuredDataPlugin::StructuredDataPlugin(const ProcessWP &process_wp)
     : PluginInterface(), m_process_wp(process_wp) {}
 
 StructuredDataPlugin::~StructuredDataPlugin() {}
 

lldb/tools/intel-features/intel-mpx/cli-wrapper-mpxtable.cpp

static bool GetInitInfo(lldb::SBDebugger debugger, lldb::SBTarget &target,
   if (!GetPtr(arg, ptr, frame, result))
     return false;
 
   return true;
 }
 
 class MPXTableShow : public lldb::SBCommandPluginInterface {
 public:
-  virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
-                         lldb::SBCommandReturnObject &result) {
+  bool DoExecute(lldb::SBDebugger debugger, char **command,
+                 lldb::SBCommandReturnObject &result) override {
 
     if (command) {
       int arg_c = 0;
       char *arg;
 
       while (*command) {
         if (arg_c >= 1) {
           result.SetError("Too many arguments. See help.");
bool DoExecute(lldb::SBDebugger debugger, char **command,
     result.SetError("Too few arguments. See help.");
     result.SetStatus(lldb::eReturnStatusFailed);
     return false;
   }
 };
 
 class MPXTableSet : public lldb::SBCommandPluginInterface {
 public:
-  virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
-                         lldb::SBCommandReturnObject &result) {
+  bool DoExecute(lldb::SBDebugger debugger, char **command,
+                 lldb::SBCommandReturnObject &result) override {
 
     if (command) {
       int arg_c = 0;
       char *arg[3];
 
       while (*command) {
         arg[arg_c] = *command;
         command++;

lldb/unittests/Editline/EditlineTest.cpp

private:
   std::shared_ptr<std::thread> _sp_output_thread;
 
 public:
   static void SetUpTestCase() {
     // We need a TERM set properly for editline to work as expected.
     setenv("TERM", "vt100", 1);
   }
 
-  void SetUp() {
+  void SetUp() override {
     FileSystem::Initialize();
 
     // Validate the editline adapter.
     EXPECT_TRUE(_el_adapter.IsValid());
     if (!_el_adapter.IsValid())
       return;
 
     // Dump output.
     _sp_output_thread =
         std::make_shared<std::thread>([&] { _el_adapter.ConsumeAllOutput(); });
   }
 
-  void TearDown() {
+  void TearDown() override {
     _el_adapter.CloseInput();
     if (_sp_output_thread)
       _sp_output_thread->join();
 
     FileSystem::Terminate();
   }
 
   EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }

lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp

 namespace {
 
 struct MockDelegate : public GDBRemoteClientBase::ContinueDelegate {
   std::string output;
   std::string misc_data;
   unsigned stop_reply_called = 0;
   std::vector<std::string> structured_data_packets;
 
-  void HandleAsyncStdout(llvm::StringRef out) { output += out; }
-  void HandleAsyncMisc(llvm::StringRef data) { misc_data += data; }
-  void HandleStopReply() { ++stop_reply_called; }
+  void HandleAsyncStdout(llvm::StringRef out) override { output += out; }
+  void HandleAsyncMisc(llvm::StringRef data) override { misc_data += data; }
+  void HandleStopReply() override { ++stop_reply_called; }
 
-  void HandleAsyncStructuredDataPacket(llvm::StringRef data) {
+  void HandleAsyncStructuredDataPacket(llvm::StringRef data) override {
     structured_data_packets.push_back(data);
   }
 };
 
 struct TestClient : public GDBRemoteClientBase {
   TestClient() : GDBRemoteClientBase("test.client", "test.client.listener") {
     m_send_acks = false;
   }

lldb/unittests/Symbol/TestClangASTContext.cpp

static void SetUpTestCase() {
     HostInfo::Initialize();
   }
 
   static void TearDownTestCase() {
     HostInfo::Terminate();
     FileSystem::Terminate();
   }
 
-  virtual void SetUp() override {
+  void SetUp() override {
     std::string triple = HostInfo::GetTargetTriple();
     m_ast.reset(new ClangASTContext(triple.c_str()));
   }
 
-  virtual void TearDown() override { m_ast.reset(); }
+  void TearDown() override { m_ast.reset(); }
 
 protected:
   std::unique_ptr<ClangASTContext> m_ast;
 
   QualType GetBasicQualType(BasicType type) const {
     return ClangUtil::GetQualType(m_ast->GetBasicTypeFromAST(type));
   }
 

lldb/unittests/Target/ProcessInstanceInfoTest.cpp

 
 using namespace lldb_private;
 
 namespace {
 /// A very simple resolver which fails for even ids and returns a simple string
 /// for odd ones.
 class DummyUserIDResolver : public UserIDResolver {
 protected:
-  llvm::Optional<std::string> DoGetUserName(id_t uid) {
+  llvm::Optional<std::string> DoGetUserName(id_t uid) override {
     if (uid % 2)
       return ("user" + llvm::Twine(uid)).str();
     return llvm::None;
   }
 
-  llvm::Optional<std::string> DoGetGroupName(id_t gid) {
+  llvm::Optional<std::string> DoGetGroupName(id_t gid) override {
     if (gid % 2)
       return ("group" + llvm::Twine(gid)).str();
     return llvm::None;
   }
 };
 } // namespace
 
 TEST(ProcessInstanceInfo, Dump) {