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 : public ClangExpressionHelper { 76 public: 77 ClangUtilityFunctionHelper() = default; 78 79 ~ClangUtilityFunctionHelper() override = default; 80 81 /// Return the object that the parser should use when resolving external 82 /// values. May be NULL if everything should be self-contained. 83 ClangExpressionDeclMap *DeclMap() override { 84 return m_expr_decl_map_up.get(); 85 } 86 87 void ResetDeclMap() { m_expr_decl_map_up.reset(); } 88 89 void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory); 90 91 /// Return the object that the parser should allow to access ASTs. May be 92 /// nullptr if the ASTs do not need to be transformed. 93 /// 94 /// \param[in] passthrough 95 /// The ASTConsumer that the returned transformer should send 96 /// the ASTs to after transformation. 97 clang::ASTConsumer * 98 ASTTransformer(clang::ASTConsumer *passthrough) override { 99 return nullptr; 100 } 101 102 private: 103 std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up; 104 }; 105 106 /// The map to use when parsing and materializing the expression. 107 ClangUtilityFunctionHelper m_type_system_helper; 108 }; 109 110 } // namespace lldb_private 111 112 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H 113