Coverage Report

Created: 2022-01-18 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h
Line
Count
Source (jump to first uncovered line)
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
3.41k
  bool isA(const void *ClassID) const override {
40
3.41k
    return ClassID == &ID || UtilityFunction::isA(ClassID);
41
3.41k
  }
42
0
  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
6.83k
  ExpressionTypeSystemHelper *GetTypeSystemHelper() override {
60
6.83k
    return &m_type_system_helper;
61
6.83k
  }
62
63
6.83k
  ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); }
64
65
3.41k
  void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); }
66
67
3.41k
  void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory) {
68
3.41k
    m_type_system_helper.ResetDeclMap(exe_ctx, keep_result_in_memory);
69
3.41k
  }
70
71
  bool Install(DiagnosticManager &diagnostic_manager,
72
               ExecutionContext &exe_ctx) override;
73
74
private:
75
  class ClangUtilityFunctionHelper : public ClangExpressionHelper {
76
  public:
77
3.41k
    ClangUtilityFunctionHelper() = default;
78
79
3.41k
    ~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
13.6k
    ClangExpressionDeclMap *DeclMap() override {
84
13.6k
      return m_expr_decl_map_up.get();
85
13.6k
    }
86
87
3.41k
    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
3.41k
    ASTTransformer(clang::ASTConsumer *passthrough) override {
99
3.41k
      return nullptr;
100
3.41k
    }
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