contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

   1 //===-- LibCxxVariant.cpp --------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "LibCxxVariant.h"
  11 #include "lldb/DataFormatters/FormattersHelpers.h"
  12
  13 #include "llvm/ADT/Optional.h"
  14 #include "llvm/ADT/ScopeExit.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 // libc++ variant implementation contains two members that we care about both
  20 // are contained in the __impl member.
  21 // - __index which tells us which of the variadic template types is the active
  22 //   type for the variant
  23 // - __data is a variadic union which recursively contains itself as member
  24 //   which refers to the tailing variadic types.
  25 //   - __head which refers to the leading non pack type
  26 //     - __value refers to the actual value contained
  27 //   - __tail which refers to the remaining pack types
  28 //
  29 // e.g. given std::variant<int,double,char> v1
  30 //
  31 // (lldb) frame var -R v1.__impl.__data
  32 //(... __union<... 0, int, double, char>) v1.__impl.__data = {
  33 // ...
  34 //  __head = {
  35 //    __value = ...
  36 //  }
  37 //  __tail = {
  38 //  ...
  39 //    __head = {
  40 //      __value = ...
  41 //    }
  42 //    __tail = {
  43 //    ...
  44 //      __head = {
  45 //        __value = ...
  46 //  ...
  47 //
  48 // So given
  49 // - __index equal to 0 the active value is contained in
  50 //
  51 //     __data.__head.__value
  52 //
  53 // - __index equal to 1 the active value is contained in
  54 //
  55 //     __data.__tail.__head.__value
  56 //
  57 // - __index equal to 2 the active value is contained in
  58 //
  59 //      __data.__tail.__tail.__head.__value
  60 //
  61
  62 namespace {
  63 // libc++ std::variant index could have one of three states
  64 // 1) VALID, we can obtain it and its not variant_npos
  65 // 2) INVALID, we can't obtain it or it is not a type we expect
  66 // 3) NPOS, its value is variant_npos which means the variant has no value
  67 enum class LibcxxVariantIndexValidity { VALID, INVALID, NPOS };
  68
  69 LibcxxVariantIndexValidity
  70 LibcxxVariantGetIndexValidity(ValueObjectSP &impl_sp) {
  71   ValueObjectSP index_sp(
  72       impl_sp->GetChildMemberWithName(ConstString("__index"), true));
  73
  74   if (!index_sp)
  75     return LibcxxVariantIndexValidity::INVALID;
  76
  77   int64_t index_value = index_sp->GetValueAsSigned(0);
  78
  79   if (index_value == -1)
  80     return LibcxxVariantIndexValidity::NPOS;
  81
  82   return LibcxxVariantIndexValidity::VALID;
  83 }
  84
  85 llvm::Optional<uint64_t> LibcxxVariantIndexValue(ValueObjectSP &impl_sp) {
  86   ValueObjectSP index_sp(
  87       impl_sp->GetChildMemberWithName(ConstString("__index"), true));
  88
  89   if (!index_sp)
  90     return {};
  91
  92   return {index_sp->GetValueAsUnsigned(0)};
  93 }
  94
  95 ValueObjectSP LibcxxVariantGetNthHead(ValueObjectSP &impl_sp, uint64_t index) {
  96   ValueObjectSP data_sp(
  97       impl_sp->GetChildMemberWithName(ConstString("__data"), true));
  98
  99   if (!data_sp)
 100     return ValueObjectSP{};
 101
 102   ValueObjectSP current_level = data_sp;
 103   for (uint64_t n = index; n != 0; --n) {
 104     ValueObjectSP tail_sp(
 105         current_level->GetChildMemberWithName(ConstString("__tail"), true));
 106
 107     if (!tail_sp)
 108       return ValueObjectSP{};
 109
 110     current_level = tail_sp;
 111   }
 112
 113   return current_level->GetChildMemberWithName(ConstString("__head"), true);
 114 }
 115 } // namespace
 116
 117 namespace lldb_private {
 118 namespace formatters {
 119 bool LibcxxVariantSummaryProvider(ValueObject &valobj, Stream &stream,
 120                                   const TypeSummaryOptions &options) {
 121   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
 122   if (!valobj_sp)
 123     return false;
 124
 125   ValueObjectSP impl_sp(
 126       valobj_sp->GetChildMemberWithName(ConstString("__impl"), true));
 127
 128   if (!impl_sp)
 129     return false;
 130
 131   LibcxxVariantIndexValidity validity = LibcxxVariantGetIndexValidity(impl_sp);
 132
 133   if (validity == LibcxxVariantIndexValidity::INVALID)
 134     return false;
 135
 136   if (validity == LibcxxVariantIndexValidity::NPOS) {
 137     stream.Printf(" No Value");
 138     return true;
 139   }
 140
 141   auto optional_index_value = LibcxxVariantIndexValue(impl_sp);
 142
 143   if (!optional_index_value)
 144     return false;
 145
 146   uint64_t index_value = *optional_index_value;
 147
 148   ValueObjectSP nth_head = LibcxxVariantGetNthHead(impl_sp, index_value);
 149
 150   if (!nth_head)
 151     return false;
 152
 153   CompilerType head_type = nth_head->GetCompilerType();
 154
 155   if (!head_type)
 156     return false;
 157
 158   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
 159
 160   if (!template_type)
 161     return false;
 162
 163   stream.Printf(" Active Type = %s ", template_type.GetTypeName().GetCString());
 164
 165   return true;
 166 }
 167 } // namespace formatters
 168 } // namespace lldb_private
 169
 170 namespace {
 171 class VariantFrontEnd : public SyntheticChildrenFrontEnd {
 172 public:
 173   VariantFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
 174     Update();
 175   }
 176
 177   size_t GetIndexOfChildWithName(const ConstString &name) override {
 178     return formatters::ExtractIndexFromString(name.GetCString());
 179   }
 180
 181   bool MightHaveChildren() override { return true; }
 182   bool Update() override;
 183   size_t CalculateNumChildren() override { return m_size; }
 184   ValueObjectSP GetChildAtIndex(size_t idx) override;
 185
 186 private:
 187   size_t m_size = 0;
 188   ValueObjectSP m_base_sp;
 189 };
 190 } // namespace
 191
 192 bool VariantFrontEnd::Update() {
 193   m_size = 0;
 194   ValueObjectSP impl_sp(
 195       m_backend.GetChildMemberWithName(ConstString("__impl"), true));
 196   if (!impl_sp)
 197     return false;
 198
 199   LibcxxVariantIndexValidity validity = LibcxxVariantGetIndexValidity(impl_sp);
 200
 201   if (validity == LibcxxVariantIndexValidity::INVALID)
 202     return false;
 203
 204   if (validity == LibcxxVariantIndexValidity::NPOS)
 205     return true;
 206
 207   m_size = 1;
 208
 209   return false;
 210 }
 211
 212 ValueObjectSP VariantFrontEnd::GetChildAtIndex(size_t idx) {
 213   if (idx >= m_size)
 214     return ValueObjectSP();
 215
 216   ValueObjectSP impl_sp(
 217       m_backend.GetChildMemberWithName(ConstString("__impl"), true));
 218
 219   auto optional_index_value = LibcxxVariantIndexValue(impl_sp);
 220
 221   if (!optional_index_value)
 222     return ValueObjectSP();
 223
 224   uint64_t index_value = *optional_index_value;
 225
 226   ValueObjectSP nth_head = LibcxxVariantGetNthHead(impl_sp, index_value);
 227
 228   if (!nth_head)
 229     return ValueObjectSP();
 230
 231   CompilerType head_type = nth_head->GetCompilerType();
 232
 233   if (!head_type)
 234     return ValueObjectSP();
 235
 236   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
 237
 238   if (!template_type)
 239     return ValueObjectSP();
 240
 241   ValueObjectSP head_value(
 242       nth_head->GetChildMemberWithName(ConstString("__value"), true));
 243
 244   if (!head_value)
 245     return ValueObjectSP();
 246
 247   return head_value->Clone(ConstString(ConstString("Value").AsCString()));
 248 }
 249
 250 SyntheticChildrenFrontEnd *
 251 formatters::LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
 252                                          lldb::ValueObjectSP valobj_sp) {
 253   if (valobj_sp)
 254     return new VariantFrontEnd(*valobj_sp);
 255   return nullptr;
 256 }