1 //===-- TypeFormat.h ----------------------------------------------*- C++ 2 //-*-===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLDB_DATAFORMATTERS_TYPEFORMAT_H 11 #define LLDB_DATAFORMATTERS_TYPEFORMAT_H 12 13 #include <functional> 14 #include <string> 15 #include <unordered_map> 16 17 18 #include "lldb/lldb-enumerations.h" 19 #include "lldb/lldb-public.h" 20 21 #include "lldb/Core/ValueObject.h" 22 23 namespace lldb_private { 24 class TypeFormatImpl { 25 public: 26 class Flags { 27 public: Flags()28 Flags() {} 29 Flags(const Flags & other)30 Flags(const Flags &other) : m_flags(other.m_flags) {} 31 Flags(uint32_t value)32 Flags(uint32_t value) : m_flags(value) {} 33 34 Flags &operator=(const Flags &rhs) { 35 if (&rhs != this) 36 m_flags = rhs.m_flags; 37 38 return *this; 39 } 40 41 Flags &operator=(const uint32_t &rhs) { 42 m_flags = rhs; 43 return *this; 44 } 45 Clear()46 Flags &Clear() { 47 m_flags = 0; 48 return *this; 49 } 50 GetCascades()51 bool GetCascades() const { 52 return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade; 53 } 54 55 Flags &SetCascades(bool value = true) { 56 if (value) 57 m_flags |= lldb::eTypeOptionCascade; 58 else 59 m_flags &= ~lldb::eTypeOptionCascade; 60 return *this; 61 } 62 GetSkipPointers()63 bool GetSkipPointers() const { 64 return (m_flags & lldb::eTypeOptionSkipPointers) == 65 lldb::eTypeOptionSkipPointers; 66 } 67 68 Flags &SetSkipPointers(bool value = true) { 69 if (value) 70 m_flags |= lldb::eTypeOptionSkipPointers; 71 else 72 m_flags &= ~lldb::eTypeOptionSkipPointers; 73 return *this; 74 } 75 GetSkipReferences()76 bool GetSkipReferences() const { 77 return (m_flags & lldb::eTypeOptionSkipReferences) == 78 lldb::eTypeOptionSkipReferences; 79 } 80 81 Flags &SetSkipReferences(bool value = true) { 82 if (value) 83 m_flags |= lldb::eTypeOptionSkipReferences; 84 else 85 m_flags &= ~lldb::eTypeOptionSkipReferences; 86 return *this; 87 } 88 GetNonCacheable()89 bool GetNonCacheable() const { 90 return (m_flags & lldb::eTypeOptionNonCacheable) == 91 lldb::eTypeOptionNonCacheable; 92 } 93 94 Flags &SetNonCacheable(bool value = true) { 95 if (value) 96 m_flags |= lldb::eTypeOptionNonCacheable; 97 else 98 m_flags &= ~lldb::eTypeOptionNonCacheable; 99 return *this; 100 } 101 GetValue()102 uint32_t GetValue() { return m_flags; } 103 SetValue(uint32_t value)104 void SetValue(uint32_t value) { m_flags = value; } 105 106 private: 107 uint32_t m_flags = lldb::eTypeOptionCascade; 108 }; 109 110 TypeFormatImpl(const Flags &flags = Flags()); 111 112 typedef std::shared_ptr<TypeFormatImpl> SharedPointer; 113 114 virtual ~TypeFormatImpl(); 115 Cascades()116 bool Cascades() const { return m_flags.GetCascades(); } 117 SkipsPointers()118 bool SkipsPointers() const { return m_flags.GetSkipPointers(); } 119 SkipsReferences()120 bool SkipsReferences() const { return m_flags.GetSkipReferences(); } 121 NonCacheable()122 bool NonCacheable() const { return m_flags.GetNonCacheable(); } 123 SetCascades(bool value)124 void SetCascades(bool value) { m_flags.SetCascades(value); } 125 SetSkipsPointers(bool value)126 void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); } 127 SetSkipsReferences(bool value)128 void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); } 129 SetNonCacheable(bool value)130 void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); } 131 GetOptions()132 uint32_t GetOptions() { return m_flags.GetValue(); } 133 SetOptions(uint32_t value)134 void SetOptions(uint32_t value) { m_flags.SetValue(value); } 135 GetRevision()136 uint32_t &GetRevision() { return m_my_revision; } 137 138 enum class Type { eTypeUnknown, eTypeFormat, eTypeEnum }; 139 GetType()140 virtual Type GetType() { return Type::eTypeUnknown; } 141 142 // we are using a ValueObject* instead of a ValueObjectSP because we do not 143 // need to hold on to this for extended periods of time and we trust the 144 // ValueObject to stay around for as long as it is required for us to 145 // generate its value 146 virtual bool FormatObject(ValueObject *valobj, std::string &dest) const = 0; 147 148 virtual std::string GetDescription() = 0; 149 150 protected: 151 Flags m_flags; 152 uint32_t m_my_revision = 0; 153 154 private: 155 TypeFormatImpl(const TypeFormatImpl &) = delete; 156 const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete; 157 }; 158 159 class TypeFormatImpl_Format : public TypeFormatImpl { 160 public: 161 TypeFormatImpl_Format(lldb::Format f = lldb::eFormatInvalid, 162 const TypeFormatImpl::Flags &flags = Flags()); 163 164 typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer; 165 166 ~TypeFormatImpl_Format() override; 167 GetFormat()168 lldb::Format GetFormat() const { return m_format; } 169 SetFormat(lldb::Format fmt)170 void SetFormat(lldb::Format fmt) { m_format = fmt; } 171 GetType()172 TypeFormatImpl::Type GetType() override { 173 return TypeFormatImpl::Type::eTypeFormat; 174 } 175 176 bool FormatObject(ValueObject *valobj, std::string &dest) const override; 177 178 std::string GetDescription() override; 179 180 protected: 181 lldb::Format m_format; 182 183 private: 184 TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete; 185 const TypeFormatImpl_Format & 186 operator=(const TypeFormatImpl_Format &) = delete; 187 }; 188 189 class TypeFormatImpl_EnumType : public TypeFormatImpl { 190 public: 191 TypeFormatImpl_EnumType(ConstString type_name = ConstString(""), 192 const TypeFormatImpl::Flags &flags = Flags()); 193 194 typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer; 195 196 ~TypeFormatImpl_EnumType() override; 197 GetTypeName()198 ConstString GetTypeName() { return m_enum_type; } 199 SetTypeName(ConstString enum_type)200 void SetTypeName(ConstString enum_type) { m_enum_type = enum_type; } 201 GetType()202 TypeFormatImpl::Type GetType() override { 203 return TypeFormatImpl::Type::eTypeEnum; 204 } 205 206 bool FormatObject(ValueObject *valobj, std::string &dest) const override; 207 208 std::string GetDescription() override; 209 210 protected: 211 ConstString m_enum_type; 212 mutable std::unordered_map<void *, CompilerType> m_types; 213 214 private: 215 TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &) = delete; 216 const TypeFormatImpl_EnumType & 217 operator=(const TypeFormatImpl_EnumType &) = delete; 218 }; 219 } // namespace lldb_private 220 221 #endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H 222