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: isA(const void * ClassID)39 bool isA(const void *ClassID) const override { 40 return ClassID == &ID || UtilityFunction::isA(ClassID); 41 } classof(const Expression * obj)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 ClangUtilityFunction(ExecutionContextScope &exe_scope, std::string text, 52 std::string name); 53 54 ~ClangUtilityFunction() override; 55 GetTypeSystemHelper()56 ExpressionTypeSystemHelper *GetTypeSystemHelper() override { 57 return &m_type_system_helper; 58 } 59 DeclMap()60 ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); } 61 ResetDeclMap()62 void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); } 63 ResetDeclMap(ExecutionContext & exe_ctx,bool keep_result_in_memory)64 void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory) { 65 m_type_system_helper.ResetDeclMap(exe_ctx, keep_result_in_memory); 66 } 67 68 bool Install(DiagnosticManager &diagnostic_manager, 69 ExecutionContext &exe_ctx) override; 70 71 private: 72 class ClangUtilityFunctionHelper : public ClangExpressionHelper { 73 public: ClangUtilityFunctionHelper()74 ClangUtilityFunctionHelper() {} 75 ~ClangUtilityFunctionHelper()76 ~ClangUtilityFunctionHelper() override {} 77 78 /// Return the object that the parser should use when resolving external 79 /// values. May be NULL if everything should be self-contained. DeclMap()80 ClangExpressionDeclMap *DeclMap() override { 81 return m_expr_decl_map_up.get(); 82 } 83 ResetDeclMap()84 void ResetDeclMap() { m_expr_decl_map_up.reset(); } 85 86 void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory); 87 88 /// Return the object that the parser should allow to access ASTs. May be 89 /// nullptr if the ASTs do not need to be transformed. 90 /// 91 /// \param[in] passthrough 92 /// The ASTConsumer that the returned transformer should send 93 /// the ASTs to after transformation. 94 clang::ASTConsumer * ASTTransformer(clang::ASTConsumer * passthrough)95 ASTTransformer(clang::ASTConsumer *passthrough) override { 96 return nullptr; 97 } 98 99 private: 100 std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up; 101 }; 102 103 /// The map to use when parsing and materializing the expression. 104 ClangUtilityFunctionHelper m_type_system_helper; 105 }; 106 107 } // namespace lldb_private 108 109 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H 110