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 
~Dematerializer()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 
IsValid()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 
Dematerializer(Materializer & materializer,lldb::StackFrameSP & frame_sp,IRMemoryMap & map,lldb::addr_t process_address)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     virtual ~PersistentVariableDelegate();
73     virtual ConstString GetName() = 0;
74     virtual void DidDematerialize(lldb::ExpressionVariableSP &variable) = 0;
75   };
76 
77   uint32_t
78   AddPersistentVariable(lldb::ExpressionVariableSP &persistent_variable_sp,
79                         PersistentVariableDelegate *delegate, Status &err);
80   uint32_t AddVariable(lldb::VariableSP &variable_sp, Status &err);
81 
82   /// Create entity from supplied ValueObject and count it as a member
83   /// of the materialized struct.
84   ///
85   /// Behaviour is undefined if 'valobj_provider' is empty.
86   ///
87   /// \param[in] name Name of variable to materialize
88   ///
89   /// \param[in] valobj_provider When materializing values multiple
90   ///            times, this callback gets used to fetch a fresh
91   ///            ValueObject corresponding to the supplied frame.
92   ///            This is mainly used for conditional breakpoints
93   ///            that re-apply an expression whatever the frame
94   ///            happens to be when the breakpoint got hit.
95   ///
96   /// \param[out] err Error status that gets set on error.
97   ///
98   /// \returns Offset in bytes of the member we just added to the
99   ///          materialized struct.
100   uint32_t AddValueObject(ConstString name,
101                           ValueObjectProviderTy valobj_provider, Status &err);
102 
103   uint32_t AddResultVariable(const CompilerType &type, bool is_lvalue,
104                              bool keep_in_memory,
105                              PersistentVariableDelegate *delegate, Status &err);
106   uint32_t AddSymbol(const Symbol &symbol_sp, Status &err);
107   uint32_t AddRegister(const RegisterInfo &register_info, Status &err);
108 
GetStructAlignment()109   uint32_t GetStructAlignment() { return m_struct_alignment; }
110 
GetStructByteSize()111   uint32_t GetStructByteSize() { return m_current_offset; }
112 
113   class Entity {
114   public:
115     Entity() = default;
116 
117     virtual ~Entity() = default;
118 
119     virtual void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
120                              lldb::addr_t process_address, Status &err) = 0;
121     virtual void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
122                                lldb::addr_t process_address,
123                                lldb::addr_t frame_top,
124                                lldb::addr_t frame_bottom, Status &err) = 0;
125     virtual void DumpToLog(IRMemoryMap &map, lldb::addr_t process_address,
126                            Log *log) = 0;
127     virtual void Wipe(IRMemoryMap &map, lldb::addr_t process_address) = 0;
128 
GetAlignment()129     uint32_t GetAlignment() { return m_alignment; }
130 
GetSize()131     uint32_t GetSize() { return m_size; }
132 
GetOffset()133     uint32_t GetOffset() { return m_offset; }
134 
SetOffset(uint32_t offset)135     void SetOffset(uint32_t offset) { m_offset = offset; }
136 
137   protected:
138     uint32_t m_alignment = 1;
139     uint32_t m_size = 0;
140     uint32_t m_offset = 0;
141   };
142 
143 private:
144   uint32_t AddStructMember(Entity &entity);
145 
146   typedef std::unique_ptr<Entity> EntityUP;
147   typedef std::vector<EntityUP> EntityVector;
148 
149   DematerializerWP m_dematerializer_wp;
150   EntityVector m_entities;
151   uint32_t m_current_offset = 0;
152   uint32_t m_struct_alignment = 8;
153 };
154 
155 } // namespace lldb_private
156 
157 #endif // LLDB_EXPRESSION_MATERIALIZER_H
158