Fix an invalid static cast in ClangExpressionParser.cpp

[aprantl]

Summary

This was found by the green dragon sanitizer bot.

[jingham]

I think you have to protect against your dyn_cast failing.

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

495–496

Don't you need to check the result of the dyn_cast?

[aprantl]

Excellent point!

[jingham]

Also naming quibble...

lldb/include/lldb/Expression/Expression.h

38

I don't think we use this naming for enum's anywhere. Since this is in the expression class, you don't need the EK. For the equivalent classof enum for ThreadPlans I use:

typedef enum {
  eKindGeneric,
  eKindNull,
  eKindBase,
  eKindCallFunction,
  eKindPython,
  eKindStepInstruction,
  etc...

This is inside a class so you don't need to namespace the enum name like we do with more general enums.

[aprantl]

I was following http://www.llvm.org/docs/HowToSetUpLLVMStyleRTTI.html I will rename it to eKind...

[aprantl]

Renamed enumerators.

lldb/include/lldb/Expression/Expression.h

 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  Expression encapsulates the
 /// objects needed to parse and interpret or JIT an expression.  It uses the
 /// expression parser appropriate to the language of the expression to produce
 /// LLVM IR from the expression.
 //----------------------------------------------------------------------
 class Expression {
 public:
+  /// Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
+  enum ExpressionKind {
+    eKindFunctionCaller,
+    eKindClangFunctionCaller,
+    eKindUserExpression,
+    eKindLLVMUserExpression,
+    eKindClangUserExpression,
+    eKindUtilityFunction,
+    eKindClangUtilityFunction,
+  };
+
   enum ResultType { eResultTypeAny, eResultTypeId };
 
-  Expression(Target &target);
+  Expression(Target &target, ExpressionKind kind);
 
-  Expression(ExecutionContextScope &exe_scope);
+  Expression(ExecutionContextScope &exe_scope, ExpressionKind kind);
 
   //------------------------------------------------------------------
   /// Destructor
   //------------------------------------------------------------------
   virtual ~Expression() {}
 
   //------------------------------------------------------------------
   /// Return the string that the parser should parse.  Must be a full
public:
 
   //------------------------------------------------------------------
   /// Called to notify the expression that its execution has finished.
   //------------------------------------------------------------------
   virtual void DidFinishExecuting() {}
 
   virtual ExpressionTypeSystemHelper *GetTypeSystemHelper() { return nullptr; }
 
+  /// LLVM-style RTTI support.
+  ExpressionKind getKind() const { return m_kind; }
+  
+private:
+  /// LLVM-style RTTI support.
+  const ExpressionKind m_kind;
 protected:
   lldb::TargetWP m_target_wp; /// Expression's always have to have a target...
   lldb::ProcessWP m_jit_process_wp; /// An expression might have a process, but
                                     /// it doesn't need to (e.g. calculator
                                     /// mode.)
   lldb::addr_t m_jit_start_addr; ///< The address of the JITted function within
                                  ///the JIT allocation.  LLDB_INVALID_ADDRESS if
                                  ///invalid.
   lldb::addr_t m_jit_end_addr;   ///< The address of the JITted function within
                                  ///the JIT allocation.  LLDB_INVALID_ADDRESS if
                                  ///invalid.
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Expression_h_

lldb/include/lldb/Expression/FunctionCaller.h

 /// pointer set to LLDB_INVALID_ADDRESS and new structure will be allocated
 /// and its address returned in that variable.
 ///
 /// Any of the methods that take arg_addr_ptr can be passed nullptr, and the
 /// argument space will be managed for you.
 //----------------------------------------------------------------------
 class FunctionCaller : public Expression {
 public:
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindFunctionCaller;
+  }
+  
   //------------------------------------------------------------------
   /// Constructor
   ///
   /// \param[in] exe_scope
   ///     An execution context scope that gets us at least a target and
   ///     process.
   ///
   /// \param[in] ast_context

lldb/include/lldb/Expression/LLVMUserExpression.h

 /// and as a backend for the expr command.  LLVMUserExpression is a virtual
 /// base class that encapsulates the objects needed to parse and JIT an
 /// expression. The actual parsing part will be provided by the specific
 /// implementations of LLVMUserExpression - which will be vended through the
 /// appropriate TypeSystem.
 //----------------------------------------------------------------------
 class LLVMUserExpression : public UserExpression {
 public:
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindLLVMUserExpression;
+  }
+
   // The IRPasses struct is filled in by a runtime after an expression is
   // compiled and can be used to to run fixups/analysis passes as required.
   // EarlyPasses are run on the generated module before lldb runs its own IR
   // fixups and inserts instrumentation code/pointer checks. LatePasses are run
   // after the module has been processed by llvm, before the module is
   // assembled and run in the ThreadPlan.
   struct IRPasses {
     IRPasses() : EarlyPasses(nullptr), LatePasses(nullptr){};
     std::shared_ptr<llvm::legacy::PassManager> EarlyPasses;
     std::shared_ptr<llvm::legacy::PassManager> LatePasses;
   };
 
   LLVMUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
                      llvm::StringRef prefix, lldb::LanguageType language,
                      ResultType desired_type,
-                     const EvaluateExpressionOptions &options);
+                     const EvaluateExpressionOptions &options,
+                     ExpressionKind kind);
   ~LLVMUserExpression() override;
 
   bool FinalizeJITExecution(
       DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
       lldb::ExpressionVariableSP &result,
       lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS,
       lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS) override;
 

lldb/include/lldb/Expression/UserExpression.h

 /// and as a backend for the expr command.  UserExpression is a virtual base
 /// class that encapsulates the objects needed to parse and interpret or
 /// JIT an expression.  The actual parsing part will be provided by the specific
 /// implementations of UserExpression - which will be vended through the
 /// appropriate TypeSystem.
 //----------------------------------------------------------------------
 class UserExpression : public Expression {
 public:
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindUserExpression;
+  }
+  
   enum { kDefaultTimeout = 500000u };
 
   //------------------------------------------------------------------
   /// Constructor
   ///
   /// \param[in] expr
   ///     The expression to parse.
   ///
   /// \param[in] expr_prefix
   ///     If non-nullptr, a C string containing translation-unit level
   ///     definitions to be included when the expression is parsed.
   ///
   /// \param[in] language
   ///     If not eLanguageTypeUnknown, a language to use when parsing
   ///     the expression.  Currently restricted to those languages
   ///     supported by Clang.
   ///
   /// \param[in] desired_type
   ///     If not eResultTypeAny, the type to use for the expression
   ///     result.
   //------------------------------------------------------------------
   UserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
                  llvm::StringRef prefix, lldb::LanguageType language,
                  ResultType desired_type,
-                 const EvaluateExpressionOptions &options);
+                 const EvaluateExpressionOptions &options,
+                 ExpressionKind kind);
 
   //------------------------------------------------------------------
   /// Destructor
   //------------------------------------------------------------------
   ~UserExpression() override;
 
   //------------------------------------------------------------------
   /// Parse the expression

lldb/include/lldb/Expression/UtilityFunction.h

 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  UtilityFunction encapsulates a
 /// self-contained function meant to be used from other code.  Utility
 /// functions can perform error-checking for ClangUserExpressions,
 //----------------------------------------------------------------------
 class UtilityFunction : public Expression {
 public:
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindUtilityFunction;
+  }
+  
   //------------------------------------------------------------------
   /// Constructor
   ///
   /// \param[in] text
   ///     The text of the function.  Must be a full translation unit.
   ///
   /// \param[in] name
   ///     The name of the function, as used in the text.
   //------------------------------------------------------------------
   UtilityFunction(ExecutionContextScope &exe_scope, const char *text,
-                  const char *name);
+                  const char *name, ExpressionKind kind);
 
   ~UtilityFunction() override;
 
   //------------------------------------------------------------------
   /// Install the utility function into a process
   ///
   /// \param[in] diagnostic_manager
   ///     A diagnostic manager to print parse errors and warnings to.

lldb/source/Expression/Expression.cpp

 //===-- Expression.cpp ------------------------------------------*- C++ -*-===//
 //
 // 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 "lldb/Expression/Expression.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb_private;
 
-Expression::Expression(Target &target)
-    : m_target_wp(target.shared_from_this()),
+Expression::Expression(Target &target, ExpressionKind kind)
+    : m_kind(kind),
+      m_target_wp(target.shared_from_this()),
       m_jit_start_addr(LLDB_INVALID_ADDRESS),
       m_jit_end_addr(LLDB_INVALID_ADDRESS) {
   // Can't make any kind of expression without a target.
   assert(m_target_wp.lock());
 }
 
-Expression::Expression(ExecutionContextScope &exe_scope)
-    : m_target_wp(exe_scope.CalculateTarget()),
+Expression::Expression(ExecutionContextScope &exe_scope, ExpressionKind kind)
+    : m_kind(kind),
+      m_target_wp(exe_scope.CalculateTarget()),
       m_jit_start_addr(LLDB_INVALID_ADDRESS),
       m_jit_end_addr(LLDB_INVALID_ADDRESS) {
   assert(m_target_wp.lock());
 }

lldb/source/Expression/FunctionCaller.cpp

 //----------------------------------------------------------------------
 // FunctionCaller constructor
 //----------------------------------------------------------------------
 FunctionCaller::FunctionCaller(ExecutionContextScope &exe_scope,
                                const CompilerType &return_type,
                                const Address &functionAddress,
                                const ValueList &arg_value_list,
                                const char *name)
-    : Expression(exe_scope), m_execution_unit_sp(), m_parser(),
+    : Expression(exe_scope, eKindFunctionCaller),
+      m_execution_unit_sp(), m_parser(),
       m_jit_module_wp(), m_name(name ? name : "<unknown>"),
       m_function_ptr(NULL), m_function_addr(functionAddress),
       m_function_return_type(return_type),
       m_wrapper_function_name("__lldb_caller_function"),
       m_wrapper_struct_name("__lldb_caller_struct"), m_wrapper_args_addrs(),
       m_struct_valid(false), m_arg_values(arg_value_list), m_compiled(false),
       m_JITted(false) {
   m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());

lldb/source/Expression/LLVMUserExpression.cpp

 
 using namespace lldb_private;
 
 LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope,
                                        llvm::StringRef expr,
                                        llvm::StringRef prefix,
                                        lldb::LanguageType language,
                                        ResultType desired_type,
-                                       const EvaluateExpressionOptions &options)
-    : UserExpression(exe_scope, expr, prefix, language, desired_type, options),
+                                       const EvaluateExpressionOptions &options,
+                                       ExpressionKind kind)
+    : UserExpression(exe_scope, expr, prefix, language, desired_type, options,
+                     kind),
       m_stack_frame_bottom(LLDB_INVALID_ADDRESS),
       m_stack_frame_top(LLDB_INVALID_ADDRESS), m_allow_cxx(false),
       m_allow_objc(false), m_transformed_text(), m_execution_unit_sp(),
       m_materializer_up(), m_jit_module_wp(), m_enforce_valid_object(true),
       m_in_cplusplus_method(false), m_in_objectivec_method(false),
       m_in_static_method(false), m_needs_object_ptr(false), m_target(NULL),
       m_can_interpret(false), m_materialized_address(LLDB_INVALID_ADDRESS) {}
 

lldb/source/Expression/UserExpression.cpp

 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
 
 UserExpression::UserExpression(ExecutionContextScope &exe_scope,
                                llvm::StringRef expr, llvm::StringRef prefix,
                                lldb::LanguageType language,
                                ResultType desired_type,
-                               const EvaluateExpressionOptions &options)
-    : Expression(exe_scope), m_expr_text(expr), m_expr_prefix(prefix),
+                               const EvaluateExpressionOptions &options,
+                               ExpressionKind kind)
+    : Expression(exe_scope, kind), m_expr_text(expr), m_expr_prefix(prefix),
       m_language(language), m_desired_type(desired_type), m_options(options) {}
 
 UserExpression::~UserExpression() {}
 
 void UserExpression::InstallContext(ExecutionContext &exe_ctx) {
   m_jit_process_wp = exe_ctx.GetProcessSP();
 
   lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();

lldb/source/Expression/UtilityFunction.cpp

 ///
 /// \param[in] text
 ///     The text of the function.  Must be a full translation unit.
 ///
 /// \param[in] name
 ///     The name of the function, as used in the text.
 //------------------------------------------------------------------
 UtilityFunction::UtilityFunction(ExecutionContextScope &exe_scope,
-                                 const char *text, const char *name)
-    : Expression(exe_scope), m_execution_unit_sp(), m_jit_module_wp(),
+                                 const char *text, const char *name,
+                                 ExpressionKind kind)
+    : Expression(exe_scope, kind),
+      m_execution_unit_sp(), m_jit_module_wp(),
       m_function_text(),
       m_function_name(name) {}
 
 UtilityFunction::~UtilityFunction() {
   lldb::ProcessSP process_sp(m_jit_process_wp.lock());
   if (process_sp) {
     lldb::ModuleSP jit_module_sp(m_jit_module_wp.lock());
     if (jit_module_sp)

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

ClangExpressionParser::ClangExpressionParser(
   lang_opts.CharIsSigned = ArchSpec(m_compiler->getTargetOpts().Triple.c_str())
                                .CharIsSignedByDefault();
 
   // Spell checking is a nice feature, but it ends up completing a lot of types
   // that we didn't strictly speaking need to complete. As a result, we spend a
   // long time parsing and importing debug information.
   lang_opts.SpellChecking = false;
 
-  auto &clang_expr = *static_cast<ClangUserExpression *>(&m_expr);
-  if (clang_expr.DidImportCxxModules()) {
+  auto *clang_expr = dyn_cast<ClangUserExpression>(&m_expr);
+  if (clang_expr && clang_expr->DidImportCxxModules()) {
     LLDB_LOG(log, "Adding lang options for importing C++ modules");
 
     lang_opts.Modules = true;
     // We want to implicitly build modules.
     lang_opts.ImplicitModules = true;
     // To automatically import all submodules when we import 'std'.
     lang_opts.ModulesLocalVisibility = false;
 

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

 /// and its address returned in that variable.
 ///
 /// Any of the methods that take arg_addr_ptr can be passed NULL, and the
 /// argument space will be managed for you.
 //----------------------------------------------------------------------
 class ClangFunctionCaller : public FunctionCaller {
   friend class ASTStructExtractor;
 
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindClangFunctionCaller;
+  }
+
   class ClangFunctionCallerHelper : public ClangExpressionHelper {
   public:
     ClangFunctionCallerHelper(ClangFunctionCaller &owner) : m_owner(owner) {}
 
     ~ClangFunctionCallerHelper() override = default;
 
     //------------------------------------------------------------------
     /// Return the object that the parser should use when resolving external

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

 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  ClangUserExpression encapsulates
 /// the objects needed to parse and interpret or JIT an expression.  It uses
 /// the Clang parser to produce LLVM IR from the expression.
 //----------------------------------------------------------------------
 class ClangUserExpression : public LLVMUserExpression {
 public:
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindClangUserExpression;
+  }
+
   enum { kDefaultTimeout = 500000u };
 
   class ClangUserExpressionHelper : public ClangExpressionHelper {
   public:
     ClangUserExpressionHelper(Target &target, bool top_level)
         : m_target(target), m_top_level(top_level) {}
 
     ~ClangUserExpressionHelper() override = default;

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

 using namespace lldb_private;
 
 ClangUserExpression::ClangUserExpression(
     ExecutionContextScope &exe_scope, llvm::StringRef expr,
     llvm::StringRef prefix, lldb::LanguageType language,
     ResultType desired_type, const EvaluateExpressionOptions &options,
     ValueObject *ctx_obj)
     : LLVMUserExpression(exe_scope, expr, prefix, language, desired_type,
-                         options),
+                         options, eKindClangUserExpression),
       m_type_system_helper(*m_target_wp.lock(), options.GetExecutionPolicy() ==
                                                     eExecutionPolicyTopLevel),
       m_result_delegate(exe_scope.CalculateTarget()), m_ctx_obj(ctx_obj) {
   switch (m_language) {
   case lldb::eLanguageTypeC_plus_plus:
     m_allow_cxx = true;
     break;
   case lldb::eLanguageTypeObjC:

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

 /// and as a backend for the expr command.  ClangUtilityFunction encapsulates
 /// a self-contained function meant to be used from other code.  Utility
 /// functions can perform error-checking for ClangUserExpressions, or can
 /// simply provide a way to push a function into the target for the debugger
 /// to call later on.
 //----------------------------------------------------------------------
 class ClangUtilityFunction : public UtilityFunction {
 public:
+  /// LLVM-style RTTI support.
+  static bool classof(const Expression *E) {
+    return E->getKind() == eKindClangUtilityFunction;
+  }
+
   class ClangUtilityFunctionHelper : public ClangExpressionHelper {
   public:
     ClangUtilityFunctionHelper() {}
 
     ~ClangUtilityFunctionHelper() override {}
 
     //------------------------------------------------------------------
     /// Return the object that the parser should use when resolving external

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

 /// \param[in] text
 ///     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::ClangUtilityFunction(ExecutionContextScope &exe_scope,
                                            const char *text, const char *name)
-    : UtilityFunction(exe_scope, text, name) {
+    : UtilityFunction(exe_scope, text, name, eKindClangUtilityFunction) {
   m_function_text.assign(ClangExpressionSourceCode::g_expression_prefix);
   if (text && text[0])
     m_function_text.append(text);
 }
 
 ClangUtilityFunction::~ClangUtilityFunction() {}
 
 //------------------------------------------------------------------