1 //===-- ClangUtilityFunction.h ----------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H 10 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H 11 12 #include <map> 13 #include <string> 14 #include <vector> 15 16 #include "ClangExpressionHelper.h" 17 18 #include "lldb/Expression/UtilityFunction.h" 19 #include "lldb/lldb-forward.h" 20 #include "lldb/lldb-private.h" 21 22 namespace lldb_private { 23 24 /// \class ClangUtilityFunction ClangUtilityFunction.h 25 /// "lldb/Expression/ClangUtilityFunction.h" Encapsulates a single expression 26 /// for use with Clang 27 /// 28 /// LLDB uses expressions for various purposes, notably to call functions 29 /// and as a backend for the expr command. ClangUtilityFunction encapsulates 30 /// a self-contained function meant to be used from other code. Utility 31 /// functions can perform error-checking for ClangUserExpressions, or can 32 /// simply provide a way to push a function into the target for the debugger 33 /// to call later on. 34 class ClangUtilityFunction : public UtilityFunction { 35 // LLVM RTTI support 36 static char ID; 37 38 public: 39 bool isA(const void *ClassID) const override { 40 return ClassID == &ID || UtilityFunction::isA(ClassID); 41 } 42 static bool classof(const Expression *obj) { return obj->isA(&ID); } 43 44 /// Constructor 45 /// 46 /// \param[in] text 47 /// The text of the function. Must be a full translation unit. 48 /// 49 /// \param[in] name 50 /// The name of the function, as used in the text. 51 /// 52 /// \param[in] enable_debugging 53 /// Enable debugging of this function. 54 ClangUtilityFunction(ExecutionContextScope &exe_scope, std::string text, 55 std::string name, bool enable_debugging); 56 57 ~ClangUtilityFunction() override; 58 59 ExpressionTypeSystemHelper *GetTypeSystemHelper() override { 60 return &m_type_system_helper; 61 } 62 63 ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); } 64 65 void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); } 66 67 void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory) { 68 m_type_system_helper.ResetDeclMap(exe_ctx, keep_result_in_memory); 69 } 70 71 bool Install(DiagnosticManager &diagnostic_manager, 72 ExecutionContext &exe_ctx) override; 73 74 private: 75 class ClangUtilityFunctionHelper 76 : public llvm::RTTIExtends<ClangUtilityFunctionHelper, 77 ClangExpressionHelper> { 78 public: 79 // LLVM RTTI support 80 static char ID; 81 82 /// Return the object that the parser should use when resolving external 83 /// values. May be NULL if everything should be self-contained. 84 ClangExpressionDeclMap *DeclMap() override { 85 return m_expr_decl_map_up.get(); 86 } 87 88 void ResetDeclMap() { m_expr_decl_map_up.reset(); } 89 90 void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory); 91 92 /// Return the object that the parser should allow to access ASTs. May be 93 /// nullptr if the ASTs do not need to be transformed. 94 /// 95 /// \param[in] passthrough 96 /// The ASTConsumer that the returned transformer should send 97 /// the ASTs to after transformation. 98 clang::ASTConsumer * 99 ASTTransformer(clang::ASTConsumer *passthrough) override { 100 return nullptr; 101 } 102 103 private: 104 std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up; 105 }; 106 107 /// The map to use when parsing and materializing the expression. 108 ClangUtilityFunctionHelper m_type_system_helper; 109 }; 110 111 } // namespace lldb_private 112 113 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H 114