LLDB  mainline
LibStdcppTuple.cpp
Go to the documentation of this file.
1 //===-- LibStdcppTuple.cpp ------------------------------------------------===//
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 #include "LibStdcpp.h"
10 
11 #include "lldb/Core/ValueObject.h"
15 
16 #include <memory>
17 #include <vector>
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 using namespace lldb_private::formatters;
22 
23 namespace {
24 
25 class LibStdcppTupleSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
26 public:
27  explicit LibStdcppTupleSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
28 
29  size_t CalculateNumChildren() override;
30 
31  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
32 
33  bool Update() override;
34 
35  bool MightHaveChildren() override;
36 
37  size_t GetIndexOfChildWithName(ConstString name) override;
38 
39 private:
40  // The lifetime of a ValueObject and all its derivative ValueObjects
41  // (children, clones, etc.) is managed by a ClusterManager. These
42  // objects are only destroyed when every shared pointer to any of them
43  // is destroyed, so we must not store a shared pointer to any ValueObject
44  // derived from our backend ValueObject (since we're in the same cluster).
45  std::vector<ValueObject*> m_members;
46 };
47 
48 } // end of anonymous namespace
49 
50 LibStdcppTupleSyntheticFrontEnd::LibStdcppTupleSyntheticFrontEnd(
51  lldb::ValueObjectSP valobj_sp)
52  : SyntheticChildrenFrontEnd(*valobj_sp) {
53  Update();
54 }
55 
56 bool LibStdcppTupleSyntheticFrontEnd::Update() {
57  m_members.clear();
58 
59  ValueObjectSP valobj_backend_sp = m_backend.GetSP();
60  if (!valobj_backend_sp)
61  return false;
62 
63  ValueObjectSP next_child_sp = valobj_backend_sp->GetNonSyntheticValue();
64  while (next_child_sp != nullptr) {
65  ValueObjectSP current_child = next_child_sp;
66  next_child_sp = nullptr;
67 
68  size_t child_count = current_child->GetNumChildren();
69  for (size_t i = 0; i < child_count; ++i) {
70  ValueObjectSP child_sp = current_child->GetChildAtIndex(i, true);
71  llvm::StringRef name_str = child_sp->GetName().GetStringRef();
72  if (name_str.startswith("std::_Tuple_impl<")) {
73  next_child_sp = child_sp;
74  } else if (name_str.startswith("std::_Head_base<")) {
75  ValueObjectSP value_sp =
76  child_sp->GetChildMemberWithName(ConstString("_M_head_impl"), true);
77  if (value_sp) {
78  StreamString name;
79  name.Printf("[%zd]", m_members.size());
80  m_members.push_back(value_sp->Clone(ConstString(name.GetString())).get());
81  }
82  }
83  }
84  }
85 
86  return false;
87 }
88 
89 bool LibStdcppTupleSyntheticFrontEnd::MightHaveChildren() { return true; }
90 
91 lldb::ValueObjectSP
92 LibStdcppTupleSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
93  if (idx < m_members.size() && m_members[idx])
94  return m_members[idx]->GetSP();
95  return lldb::ValueObjectSP();
96 }
97 
99  return m_members.size();
100 }
101 
102 size_t LibStdcppTupleSyntheticFrontEnd::GetIndexOfChildWithName(
103  ConstString name) {
104  return ExtractIndexFromString(name.GetCString());
105 }
106 
109  CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
110  return (valobj_sp ? new LibStdcppTupleSyntheticFrontEnd(valobj_sp) : nullptr);
111 }
A class that represents a running process on the host machine.
size_t ExtractIndexFromString(const char *item_name)
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
static size_t CalculateNumChildren(CompilerType container_type, CompilerType element_type, lldb_private::ExecutionContextScope *exe_scope=nullptr)
Definition: VectorType.cpp:169
A uniqued constant string class.
Definition: ConstString.h:40
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:246
Definition: SBAddress.h:15
SyntheticChildrenFrontEnd * LibStdcppTupleSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP)