diff --git a/lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h b/lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h --- a/lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h +++ b/lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h @@ -25,21 +25,9 @@ class ExpressionTypeSystemHelper { public: - enum LLVMCastKind { - eKindClangHelper, - eKindSwiftHelper, - eKindGoHelper, - kNumKinds - }; + virtual ~ExpressionTypeSystemHelper() = default; - LLVMCastKind getKind() const { return m_kind; } - - ExpressionTypeSystemHelper(LLVMCastKind kind) : m_kind(kind) {} - - ~ExpressionTypeSystemHelper() = default; - -protected: - LLVMCastKind m_kind; + virtual bool isA(const void *ClassID) const = 0; }; } // namespace lldb_private diff --git a/lldb/include/lldb/Expression/ExpressionVariable.h b/lldb/include/lldb/Expression/ExpressionVariable.h --- a/lldb/include/lldb/Expression/ExpressionVariable.h +++ b/lldb/include/lldb/Expression/ExpressionVariable.h @@ -24,13 +24,12 @@ class ExpressionVariable : public std::enable_shared_from_this { public: - // See TypeSystem.h for how to add subclasses to this. - enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds }; + ExpressionVariable(); - LLVMCastKind getKind() const { return m_kind; } + virtual ~ExpressionVariable() = default; - ExpressionVariable(LLVMCastKind kind); - virtual ~ExpressionVariable(); + // LLVM RTTI support + virtual bool isA(const void *ClassID) const = 0; std::optional GetByteSize() { return m_frozen_sp->GetByteSize(); } @@ -109,7 +108,6 @@ // these should be private lldb::ValueObjectSP m_frozen_sp; lldb::ValueObjectSP m_live_sp; - LLVMCastKind m_kind; }; /// \class ExpressionVariableList ExpressionVariable.h @@ -202,14 +200,11 @@ class PersistentExpressionState : public ExpressionVariableList { public: - // See TypeSystem.h for how to add subclasses to this. - enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds }; - - LLVMCastKind getKind() const { return m_kind; } - - PersistentExpressionState(LLVMCastKind kind); virtual ~PersistentExpressionState(); + // LLVM RTTI support + virtual bool isA(const void *ClassID) const = 0; + virtual lldb::ExpressionVariableSP CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) = 0; @@ -237,8 +232,6 @@ GetPersistentVariablePrefix(bool is_error = false) const = 0; private: - LLVMCastKind m_kind; - typedef std::set ExecutionUnitSet; ExecutionUnitSet m_execution_units; ///< The execution units that contain valuable symbols. diff --git a/lldb/include/lldb/Expression/REPL.h b/lldb/include/lldb/Expression/REPL.h --- a/lldb/include/lldb/Expression/REPL.h +++ b/lldb/include/lldb/Expression/REPL.h @@ -20,15 +20,13 @@ class REPL : public IOHandlerDelegate { public: - // See TypeSystem.h for how to add subclasses to this. - enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds }; - - LLVMCastKind getKind() const { return m_kind; } - - REPL(LLVMCastKind kind, Target &target); + REPL(Target &target); ~REPL() override; + // LLVM RTTI support + virtual bool isA(const void *ClassID) const = 0; + /// Get a REPL with an existing target (or, failing that, a debugger to use), /// and (optional) extra arguments for the compiler. /// @@ -168,7 +166,6 @@ Target &m_target; lldb::IOHandlerSP m_io_handler_sp; - LLVMCastKind m_kind; private: std::string GetSourcePath(); diff --git a/lldb/source/Expression/ExpressionVariable.cpp b/lldb/source/Expression/ExpressionVariable.cpp --- a/lldb/source/Expression/ExpressionVariable.cpp +++ b/lldb/source/Expression/ExpressionVariable.cpp @@ -15,9 +15,7 @@ using namespace lldb_private; -ExpressionVariable::ExpressionVariable(LLVMCastKind kind) - : m_flags(0), m_kind(kind) {} -ExpressionVariable::~ExpressionVariable() = default; +ExpressionVariable::ExpressionVariable() : m_flags(0) {} uint8_t *ExpressionVariable::GetValueBytes() { std::optional byte_size = m_frozen_sp->GetByteSize(); @@ -32,8 +30,6 @@ return nullptr; } -PersistentExpressionState::PersistentExpressionState(LLVMCastKind kind) - : m_kind(kind) {} PersistentExpressionState::~PersistentExpressionState() = default; lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) { diff --git a/lldb/source/Expression/REPL.cpp b/lldb/source/Expression/REPL.cpp --- a/lldb/source/Expression/REPL.cpp +++ b/lldb/source/Expression/REPL.cpp @@ -22,7 +22,7 @@ using namespace lldb_private; -REPL::REPL(LLVMCastKind kind, Target &target) : m_target(target), m_kind(kind) { +REPL::REPL(Target &target) : m_target(target) { // Make sure all option values have sane defaults Debugger &debugger = m_target.GetDebugger(); debugger.SetShowProgress(false); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt b/lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt --- a/lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt +++ b/lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt @@ -7,6 +7,7 @@ ClangASTSource.cpp ClangDeclVendor.cpp ClangExpressionDeclMap.cpp + ClangExpressionHelper.cpp ClangExpressionParser.cpp ClangExpressionSourceCode.cpp ClangExpressionUtil.cpp diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h @@ -28,17 +28,16 @@ // ClangExpressionHelper class ClangExpressionHelper : public ExpressionTypeSystemHelper { + // LLVM RTTI support + static char ID; + public: - static bool classof(const ExpressionTypeSystemHelper *ts) { - return ts->getKind() == eKindClangHelper; + // LLVM casting support + static bool classof(const ExpressionTypeSystemHelper *helper) { + return helper->isA(&ID); } - ClangExpressionHelper() - : ExpressionTypeSystemHelper( - ExpressionTypeSystemHelper::LLVMCastKind::eKindClangHelper) {} - - /// Destructor - virtual ~ClangExpressionHelper() = default; + bool isA(const void *ClassID) const override { return ClassID == &ID; } /// Return the object that the parser should use when resolving external /// values. May be NULL if everything should be self-contained. @@ -54,8 +53,6 @@ ASTTransformer(clang::ASTConsumer *passthrough) = 0; virtual void CommitPersistentDecls() {} - -protected: }; } // namespace lldb_private diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.cpp new file mode 100644 --- /dev/null +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.cpp @@ -0,0 +1,13 @@ +//===-- ClangExpressionHelper.cpp -----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "ClangExpressionHelper.h" + +using namespace lldb_private; + +char ClangExpressionHelper::ID; diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h @@ -58,6 +58,9 @@ /// This class supports all of these use cases using simple type polymorphism, /// and provides necessary support methods. Its interface is RTTI-neutral. class ClangExpressionVariable : public ExpressionVariable { + // LLVM RTTI support + static char ID; + public: ClangExpressionVariable(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size); @@ -197,10 +200,10 @@ TypeFromUser GetTypeFromUser(); - // llvm casting support - static bool classof(const ExpressionVariable *ev) { - return ev->getKind() == ExpressionVariable::eKindClang; - } + // LLVM casting support + bool isA(const void *ClassID) const override { return ClassID == &ID; } + + static bool classof(const ExpressionVariable *var) { return var->isA(&ID); } /// Members ClangExpressionVariable(const ClangExpressionVariable &) = delete; diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp @@ -20,11 +20,12 @@ using namespace lldb_private; using namespace clang; +char ClangExpressionVariable::ID; + ClangExpressionVariable::ClangExpressionVariable( ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size) - : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), - m_jit_vars() { + : m_parser_vars(), m_jit_vars() { m_flags = EVNone; m_frozen_sp = ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size); @@ -33,16 +34,14 @@ ClangExpressionVariable::ClangExpressionVariable( ExecutionContextScope *exe_scope, Value &value, ConstString name, uint16_t flags) - : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), - m_jit_vars() { + : m_parser_vars(), m_jit_vars() { m_flags = flags; m_frozen_sp = ValueObjectConstResult::Create(exe_scope, value, name); } ClangExpressionVariable::ClangExpressionVariable( const lldb::ValueObjectSP &valobj_sp) - : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), - m_jit_vars() { + : m_parser_vars(), m_jit_vars() { m_flags = EVNone; m_frozen_sp = valobj_sp; } @@ -51,8 +50,7 @@ ExecutionContextScope *exe_scope, ConstString name, const TypeFromUser &user_type, lldb::ByteOrder byte_order, uint32_t addr_byte_size) - : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), - m_jit_vars() { + : m_parser_vars(), m_jit_vars() { m_flags = EVNone; m_frozen_sp = ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h @@ -61,8 +61,6 @@ public: ClangFunctionCallerHelper(ClangFunctionCaller &owner) : m_owner(owner) {} - ~ClangFunctionCallerHelper() override = default; - /// Return the object that the parser should use when resolving external /// values. May be NULL if everything should be self-contained. ClangExpressionDeclMap *DeclMap() override { return nullptr; } diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h @@ -32,14 +32,19 @@ /// ClangPersistentVariable for more discussion. Also provides an increasing, /// 0-based counter for naming result variables. class ClangPersistentVariables : public PersistentExpressionState { + // LLVM RTTI support + static char ID; + public: ClangPersistentVariables(std::shared_ptr target_sp); ~ClangPersistentVariables() override = default; - // llvm casting support - static bool classof(const PersistentExpressionState *pv) { - return pv->getKind() == PersistentExpressionState::eKindClang; + // LLVM casting support + bool isA(const void *ClassID) const override { return ClassID == &ID; } + + static bool classof(const PersistentExpressionState *state) { + return state->isA(&ID); } std::shared_ptr GetClangASTImporter(); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp @@ -26,10 +26,11 @@ using namespace lldb; using namespace lldb_private; +char ClangPersistentVariables::ID; + ClangPersistentVariables::ClangPersistentVariables( std::shared_ptr target_sp) - : lldb_private::PersistentExpressionState(LLVMCastKind::eKindClang), - m_target_sp(target_sp) {} + : m_target_sp(target_sp) {} ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable( const lldb::ValueObjectSP &valobj_sp) { diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h @@ -56,8 +56,6 @@ ClangUserExpressionHelper(Target &target, bool top_level) : m_target(target), m_top_level(top_level) {} - ~ClangUserExpressionHelper() override = default; - /// Return the object that the parser should use when resolving external /// values. May be NULL if everything should be self-contained. ClangExpressionDeclMap *DeclMap() override { diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h @@ -74,10 +74,6 @@ private: class ClangUtilityFunctionHelper : public ClangExpressionHelper { public: - ClangUtilityFunctionHelper() = default; - - ~ClangUtilityFunctionHelper() override = default; - /// Return the object that the parser should use when resolving external /// values. May be NULL if everything should be self-contained. ClangExpressionDeclMap *DeclMap() override { diff --git a/lldb/source/Plugins/REPL/Clang/ClangREPL.h b/lldb/source/Plugins/REPL/Clang/ClangREPL.h --- a/lldb/source/Plugins/REPL/Clang/ClangREPL.h +++ b/lldb/source/Plugins/REPL/Clang/ClangREPL.h @@ -15,6 +15,9 @@ /// Implements a Clang-based REPL for C languages on top of LLDB's REPL /// framework. class ClangREPL : public REPL { + // LLVM RTTI support + static char ID; + public: ClangREPL(lldb::LanguageType language, Target &target); @@ -30,6 +33,9 @@ static llvm::StringRef GetPluginNameStatic() { return "ClangREPL"; } + // LLVM casting support + bool isA(const void *ClassID) const override { return ClassID == &ID; } + protected: Status DoInitialization() override; diff --git a/lldb/source/Plugins/REPL/Clang/ClangREPL.cpp b/lldb/source/Plugins/REPL/Clang/ClangREPL.cpp --- a/lldb/source/Plugins/REPL/Clang/ClangREPL.cpp +++ b/lldb/source/Plugins/REPL/Clang/ClangREPL.cpp @@ -15,8 +15,10 @@ LLDB_PLUGIN_DEFINE(ClangREPL) +char ClangREPL::ID; + ClangREPL::ClangREPL(lldb::LanguageType language, Target &target) - : REPL(eKindClang, target), m_language(language), + : REPL(target), m_language(language), m_implicit_expr_result_regex("\\$[0-9]+") {} ClangREPL::~ClangREPL() = default;