contrib/llvm-project/lldb/include/lldb/DataFormatters/TypeFormat.h

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