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