1 | //===-- Materializer.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_EXPRESSION_MATERIALIZER_H |
10 | #define LLDB_EXPRESSION_MATERIALIZER_H |
11 | |
12 | #include <memory> |
13 | #include <vector> |
14 | |
15 | #include "lldb/Expression/IRMemoryMap.h" |
16 | #include "lldb/Symbol/TaggedASTType.h" |
17 | #include "lldb/Target/StackFrame.h" |
18 | #include "lldb/Utility/Status.h" |
19 | #include "lldb/lldb-private-types.h" |
20 | |
21 | namespace lldb_private { |
22 | |
23 | class Materializer { |
24 | public: |
25 | Materializer() = default; |
26 | ~Materializer(); |
27 | |
28 | class Dematerializer { |
29 | public: |
30 | Dematerializer() = default; |
31 | |
32 | ~Dematerializer() { Wipe(); } |
33 | |
34 | void Dematerialize(Status &err, lldb::addr_t frame_top, |
35 | lldb::addr_t frame_bottom); |
36 | |
37 | void Wipe(); |
38 | |
39 | bool IsValid() { |
40 | return m_materializer && m_map && |
41 | (m_process_address != LLDB_INVALID_ADDRESS); |
42 | } |
43 | |
44 | private: |
45 | friend class Materializer; |
46 | |
47 | Dematerializer(Materializer &materializer, lldb::StackFrameSP &frame_sp, |
48 | IRMemoryMap &map, lldb::addr_t process_address) |
49 | : m_materializer(&materializer), m_map(&map), |
50 | m_process_address(process_address) { |
51 | if (frame_sp) { |
52 | m_thread_wp = frame_sp->GetThread(); |
53 | m_stack_id = frame_sp->GetStackID(); |
54 | } |
55 | } |
56 | |
57 | Materializer *m_materializer = nullptr; |
58 | lldb::ThreadWP m_thread_wp; |
59 | StackID m_stack_id; |
60 | IRMemoryMap *m_map = nullptr; |
61 | lldb::addr_t m_process_address = LLDB_INVALID_ADDRESS; |
62 | }; |
63 | |
64 | typedef std::shared_ptr<Dematerializer> DematerializerSP; |
65 | typedef std::weak_ptr<Dematerializer> DematerializerWP; |
66 | |
67 | DematerializerSP Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map, |
68 | lldb::addr_t process_address, Status &err); |
69 | |
70 | class PersistentVariableDelegate { |
71 | public: |
72 | PersistentVariableDelegate(); |
73 | virtual ~PersistentVariableDelegate(); |
74 | virtual ConstString GetName() = 0; |
75 | virtual void DidDematerialize(lldb::ExpressionVariableSP &variable) = 0; |
76 | }; |
77 | |
78 | uint32_t |
79 | AddPersistentVariable(lldb::ExpressionVariableSP &persistent_variable_sp, |
80 | PersistentVariableDelegate *delegate, Status &err); |
81 | uint32_t AddVariable(lldb::VariableSP &variable_sp, Status &err); |
82 | |
83 | /// Create entity from supplied ValueObject and count it as a member |
84 | /// of the materialized struct. |
85 | /// |
86 | /// Behaviour is undefined if 'valobj_provider' is empty. |
87 | /// |
88 | /// \param[in] name Name of variable to materialize |
89 | /// |
90 | /// \param[in] valobj_provider When materializing values multiple |
91 | /// times, this callback gets used to fetch a fresh |
92 | /// ValueObject corresponding to the supplied frame. |
93 | /// This is mainly used for conditional breakpoints |
94 | /// that re-apply an expression whatever the frame |
95 | /// happens to be when the breakpoint got hit. |
96 | /// |
97 | /// \param[out] err Error status that gets set on error. |
98 | /// |
99 | /// \returns Offset in bytes of the member we just added to the |
100 | /// materialized struct. |
101 | uint32_t AddValueObject(ConstString name, |
102 | ValueObjectProviderTy valobj_provider, Status &err); |
103 | |
104 | uint32_t AddResultVariable(const CompilerType &type, bool is_lvalue, |
105 | bool keep_in_memory, |
106 | PersistentVariableDelegate *delegate, Status &err); |
107 | uint32_t AddSymbol(const Symbol &symbol_sp, Status &err); |
108 | uint32_t AddRegister(const RegisterInfo ®ister_info, Status &err); |
109 | |
110 | uint32_t GetStructAlignment() { return m_struct_alignment; } |
111 | |
112 | uint32_t GetStructByteSize() { return m_current_offset; } |
113 | |
114 | class Entity { |
115 | public: |
116 | Entity() = default; |
117 | |
118 | virtual ~Entity() = default; |
119 | |
120 | virtual void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map, |
121 | lldb::addr_t process_address, Status &err) = 0; |
122 | virtual void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map, |
123 | lldb::addr_t process_address, |
124 | lldb::addr_t frame_top, |
125 | lldb::addr_t frame_bottom, Status &err) = 0; |
126 | virtual void DumpToLog(IRMemoryMap &map, lldb::addr_t process_address, |
127 | Log *log) = 0; |
128 | virtual void Wipe(IRMemoryMap &map, lldb::addr_t process_address) = 0; |
129 | |
130 | uint32_t GetAlignment() { return m_alignment; } |
131 | |
132 | uint32_t GetSize() { return m_size; } |
133 | |
134 | uint32_t GetOffset() { return m_offset; } |
135 | |
136 | void SetOffset(uint32_t offset) { m_offset = offset; } |
137 | |
138 | protected: |
139 | uint32_t m_alignment = 1; |
140 | uint32_t m_size = 0; |
141 | uint32_t m_offset = 0; |
142 | }; |
143 | |
144 | private: |
145 | uint32_t AddStructMember(Entity &entity); |
146 | |
147 | typedef std::unique_ptr<Entity> EntityUP; |
148 | typedef std::vector<EntityUP> EntityVector; |
149 | |
150 | DematerializerWP m_dematerializer_wp; |
151 | EntityVector m_entities; |
152 | uint32_t m_current_offset = 0; |
153 | uint32_t m_struct_alignment = 8; |
154 | }; |
155 | |
156 | } // namespace lldb_private |
157 | |
158 | #endif // LLDB_EXPRESSION_MATERIALIZER_H |
159 | |