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 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 GetStructAlignment()110 uint32_t GetStructAlignment() { return m_struct_alignment; } 111 GetStructByteSize()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 GetAlignment()130 uint32_t GetAlignment() { return m_alignment; } 131 GetSize()132 uint32_t GetSize() { return m_size; } 133 GetOffset()134 uint32_t GetOffset() { return m_offset; } 135 SetOffset(uint32_t offset)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