LLDB  mainline
SBTypeSummary.cpp
Go to the documentation of this file.
1 //===-- SBTypeSummary.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 
10 #include "SBReproducerPrivate.h"
11 #include "Utils.h"
12 #include "lldb/API/SBStream.h"
13 #include "lldb/API/SBValue.h"
15 
16 #include "llvm/Support/Casting.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
23 
24  m_opaque_up = std::make_unique<TypeSummaryOptions>();
25 }
26 
28  const lldb::SBTypeSummaryOptions &rhs) {
30  (const lldb::SBTypeSummaryOptions &), rhs);
31 
32  m_opaque_up = clone(rhs.m_opaque_up);
33 }
34 
36 
39  return this->operator bool();
40 }
41 SBTypeSummaryOptions::operator bool() const {
43 
44  return m_opaque_up.get();
45 }
46 
49  GetLanguage);
50 
51  if (IsValid())
52  return m_opaque_up->GetLanguage();
54 }
55 
58  GetCapping);
59 
60  if (IsValid())
61  return m_opaque_up->GetCapping();
62  return eTypeSummaryCapped;
63 }
64 
66  LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
67  (lldb::LanguageType), l);
68 
69  if (IsValid())
70  m_opaque_up->SetLanguage(l);
71 }
72 
74  LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
76 
77  if (IsValid())
78  m_opaque_up->SetCapping(c);
79 }
80 
82  return m_opaque_up.get();
83 }
84 
86 operator->() const {
87  return m_opaque_up.get();
88 }
89 
91  return m_opaque_up.get();
92 }
93 
95  return *m_opaque_up;
96 }
97 
99  return *m_opaque_up;
100 }
101 
103  const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
106  lldb_object_ptr);
107 
108  SetOptions(lldb_object_ptr);
109 }
110 
112  const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
113  if (lldb_object_ptr)
114  m_opaque_up = std::make_unique<TypeSummaryOptions>(*lldb_object_ptr);
115  else
116  m_opaque_up = std::make_unique<TypeSummaryOptions>();
117 }
118 
119 SBTypeSummary::SBTypeSummary() : m_opaque_sp() {
121 }
122 
124  uint32_t options) {
126  CreateWithSummaryString, (const char *, uint32_t),
127  data, options);
128 
129  if (!data || data[0] == 0)
131 
132  return LLDB_RECORD_RESULT(
133  SBTypeSummary(TypeSummaryImplSP(new StringSummaryFormat(options, data))));
134 }
135 
137  uint32_t options) {
139  CreateWithFunctionName, (const char *, uint32_t),
140  data, options);
141 
142  if (!data || data[0] == 0)
144 
145  return LLDB_RECORD_RESULT(
146  SBTypeSummary(TypeSummaryImplSP(new ScriptSummaryFormat(options, data))));
147 }
148 
150  uint32_t options) {
152  CreateWithScriptCode, (const char *, uint32_t),
153  data, options);
154 
155  if (!data || data[0] == 0)
157 
159  TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data))));
160 }
161 
163  uint32_t options,
164  const char *description) {
167  (lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb,
168  options, description);
169 
170  SBTypeSummary retval;
171  if (cb) {
172  retval.SetSP(TypeSummaryImplSP(new CXXFunctionSummaryFormat(
173  options,
174  [cb](ValueObject &valobj, Stream &stm,
175  const TypeSummaryOptions &opt) -> bool {
176  SBStream stream;
177  SBValue sb_value(valobj.GetSP());
178  SBTypeSummaryOptions options(&opt);
179  if (!cb(sb_value, options, stream))
180  return false;
181  stm.Write(stream.GetData(), stream.GetSize());
182  return true;
183  },
184  description ? description : "callback summary formatter")));
185  }
186 
187  return retval;
188 }
189 
191  : m_opaque_sp(rhs.m_opaque_sp) {
193 }
194 
196 
199  return this->operator bool();
200 }
201 SBTypeSummary::operator bool() const {
202  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool);
203 
204  return m_opaque_sp.get() != nullptr;
205 }
206 
209 
210  if (!IsValid())
211  return false;
212  if (ScriptSummaryFormat *script_summary_ptr =
213  llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
214  const char *ftext = script_summary_ptr->GetPythonScript();
215  return (ftext && *ftext != 0);
216  }
217  return false;
218 }
219 
222 
223  if (!IsValid())
224  return false;
225  if (ScriptSummaryFormat *script_summary_ptr =
226  llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
227  const char *ftext = script_summary_ptr->GetPythonScript();
228  return (!ftext || *ftext == 0);
229  }
230  return false;
231 }
232 
235 
236  if (!IsValid())
237  return false;
238 
239  return m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eSummaryString;
240 }
241 
242 const char *SBTypeSummary::GetData() {
244 
245  if (!IsValid())
246  return nullptr;
247  if (ScriptSummaryFormat *script_summary_ptr =
248  llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
249  const char *fname = script_summary_ptr->GetFunctionName();
250  const char *ftext = script_summary_ptr->GetPythonScript();
251  if (ftext && *ftext)
252  return ftext;
253  return fname;
254  } else if (StringSummaryFormat *string_summary_ptr =
255  llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get()))
256  return string_summary_ptr->GetSummaryString();
257  return nullptr;
258 }
259 
262 
263  if (!IsValid())
264  return lldb::eTypeOptionNone;
265  return m_opaque_sp->GetOptions();
266 }
267 
270 
271  if (!CopyOnWrite_Impl())
272  return;
273  m_opaque_sp->SetOptions(value);
274 }
275 
276 void SBTypeSummary::SetSummaryString(const char *data) {
277  LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
278  data);
279 
280  if (!IsValid())
281  return;
282  if (!llvm::isa<StringSummaryFormat>(m_opaque_sp.get()))
283  ChangeSummaryType(false);
284  if (StringSummaryFormat *string_summary_ptr =
285  llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get()))
286  string_summary_ptr->SetSummaryString(data);
287 }
288 
289 void SBTypeSummary::SetFunctionName(const char *data) {
290  LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
291  data);
292 
293  if (!IsValid())
294  return;
295  if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get()))
296  ChangeSummaryType(true);
297  if (ScriptSummaryFormat *script_summary_ptr =
298  llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get()))
299  script_summary_ptr->SetFunctionName(data);
300 }
301 
302 void SBTypeSummary::SetFunctionCode(const char *data) {
303  LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
304  data);
305 
306  if (!IsValid())
307  return;
308  if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get()))
309  ChangeSummaryType(true);
310  if (ScriptSummaryFormat *script_summary_ptr =
311  llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get()))
312  script_summary_ptr->SetPythonScript(data);
313 }
314 
316  lldb::DescriptionLevel description_level) {
318  (lldb::SBStream &, lldb::DescriptionLevel), description,
319  description_level);
320 
321  if (!CopyOnWrite_Impl())
322  return false;
323  else {
324  description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
325  return true;
326  }
327 }
328 
331  value);
332 
333  if (!IsValid())
334  return false;
335  lldb::ValueObjectSP value_sp = value.GetSP();
336  return m_opaque_sp->DoesPrintValue(value_sp.get());
337 }
338 
341  SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
342  rhs);
343 
344  if (this != &rhs) {
345  m_opaque_sp = rhs.m_opaque_sp;
346  }
347  return LLDB_RECORD_RESULT(*this);
348 }
349 
352  rhs);
353 
354  if (!IsValid())
355  return !rhs.IsValid();
356  return m_opaque_sp == rhs.m_opaque_sp;
357 }
358 
361  rhs);
362 
363  if (IsValid()) {
364  // valid and invalid are different
365  if (!rhs.IsValid())
366  return false;
367  } else {
368  // invalid and valid are different
369  if (rhs.IsValid())
370  return false;
371  else
372  // both invalid are the same
373  return true;
374  }
375 
376  if (m_opaque_sp->GetKind() != rhs.m_opaque_sp->GetKind())
377  return false;
378 
379  switch (m_opaque_sp->GetKind()) {
380  case TypeSummaryImpl::Kind::eCallback:
381  return llvm::dyn_cast<CXXFunctionSummaryFormat>(m_opaque_sp.get()) ==
382  llvm::dyn_cast<CXXFunctionSummaryFormat>(rhs.m_opaque_sp.get());
383  case TypeSummaryImpl::Kind::eScript:
384  if (IsFunctionCode() != rhs.IsFunctionCode())
385  return false;
386  if (IsFunctionName() != rhs.IsFunctionName())
387  return false;
388  return GetOptions() == rhs.GetOptions();
389  case TypeSummaryImpl::Kind::eSummaryString:
390  if (IsSummaryString() != rhs.IsSummaryString())
391  return false;
392  return GetOptions() == rhs.GetOptions();
393  case TypeSummaryImpl::Kind::eInternal:
394  return (m_opaque_sp.get() == rhs.m_opaque_sp.get());
395  }
396 
397  return false;
398 }
399 
402  rhs);
403 
404  if (!IsValid())
405  return !rhs.IsValid();
406  return m_opaque_sp != rhs.m_opaque_sp;
407 }
408 
409 lldb::TypeSummaryImplSP SBTypeSummary::GetSP() { return m_opaque_sp; }
410 
411 void SBTypeSummary::SetSP(const lldb::TypeSummaryImplSP &typesummary_impl_sp) {
412  m_opaque_sp = typesummary_impl_sp;
413 }
414 
415 SBTypeSummary::SBTypeSummary(const lldb::TypeSummaryImplSP &typesummary_impl_sp)
416  : m_opaque_sp(typesummary_impl_sp) {}
417 
419  if (!IsValid())
420  return false;
421 
422  if (m_opaque_sp.unique())
423  return true;
424 
425  TypeSummaryImplSP new_sp;
426 
427  if (CXXFunctionSummaryFormat *current_summary_ptr =
428  llvm::dyn_cast<CXXFunctionSummaryFormat>(m_opaque_sp.get())) {
429  new_sp = TypeSummaryImplSP(new CXXFunctionSummaryFormat(
430  GetOptions(), current_summary_ptr->m_impl,
431  current_summary_ptr->m_description.c_str()));
432  } else if (ScriptSummaryFormat *current_summary_ptr =
433  llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
434  new_sp = TypeSummaryImplSP(new ScriptSummaryFormat(
435  GetOptions(), current_summary_ptr->GetFunctionName(),
436  current_summary_ptr->GetPythonScript()));
437  } else if (StringSummaryFormat *current_summary_ptr =
438  llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get())) {
439  new_sp = TypeSummaryImplSP(new StringSummaryFormat(
440  GetOptions(), current_summary_ptr->GetSummaryString()));
441  }
442 
443  SetSP(new_sp);
444 
445  return nullptr != new_sp.get();
446 }
447 
448 bool SBTypeSummary::ChangeSummaryType(bool want_script) {
449  if (!IsValid())
450  return false;
451 
452  TypeSummaryImplSP new_sp;
453 
454  if (want_script ==
455  (m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eScript)) {
456  if (m_opaque_sp->GetKind() ==
458  !want_script)
459  new_sp = TypeSummaryImplSP(new StringSummaryFormat(GetOptions(), ""));
460  else
461  return CopyOnWrite_Impl();
462  }
463 
464  if (!new_sp) {
465  if (want_script)
466  new_sp = TypeSummaryImplSP(new ScriptSummaryFormat(GetOptions(), "", ""));
467  else
468  new_sp = TypeSummaryImplSP(new StringSummaryFormat(GetOptions(), ""));
469  }
470 
471  SetSP(new_sp);
472 
473  return true;
474 }
475 
476 namespace lldb_private {
477 namespace repro {
478 
479 template <>
483  (const lldb::SBTypeSummaryOptions &));
484  LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
485  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
487  ());
489  GetCapping, ());
490  LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
492  LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
496 }
497 
498 template <>
502  CreateWithSummaryString,
503  (const char *, uint32_t));
505  CreateWithFunctionName,
506  (const char *, uint32_t));
508  CreateWithScriptCode, (const char *, uint32_t));
510  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
511  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
512  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
513  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
514  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
515  LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
516  LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
517  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
518  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
519  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
520  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
521  LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
523  LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
526  SBTypeSummary, operator=,(const lldb::SBTypeSummary &));
528  SBTypeSummary, operator==,(lldb::SBTypeSummary &));
529  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
530  (lldb::SBTypeSummary &));
532  SBTypeSummary, operator!=,(lldb::SBTypeSummary &));
533 }
534 
535 }
536 }
lldb::SBTypeSummary::GetSP
lldb::TypeSummaryImplSP GetSP()
Definition: SBTypeSummary.cpp:409
lldb::SBTypeSummary::CreateWithSummaryString
static SBTypeSummary CreateWithSummaryString(const char *data, uint32_t options=0)
Definition: SBTypeSummary.cpp:123
lldb_private::repro::RegisterMethods< SBTypeSummary >
void RegisterMethods< SBTypeSummary >(Registry &R)
Definition: SBTypeSummary.cpp:499
lldb::SBTypeSummaryOptions::GetLanguage
lldb::LanguageType GetLanguage()
Definition: SBTypeSummary.cpp:47
lldb::SBTypeSummary::SetSP
void SetSP(const lldb::TypeSummaryImplSP &typefilter_impl_sp)
Definition: SBTypeSummary.cpp:411
lldb::SBTypeSummary::IsSummaryString
bool IsSummaryString()
Definition: SBTypeSummary.cpp:233
lldb::SBStream::Printf
void Printf(const char *format,...) __attribute__((format(printf
Definition: SBStream.cpp:69
SBTypeSummary.h
lldb::SBTypeSummary::FormatCallback
bool(* FormatCallback)(SBValue, SBTypeSummaryOptions, SBStream &)
Definition: SBTypeSummary.h:62
LLDB_RECORD_RESULT
#define LLDB_RECORD_RESULT(Result)
Definition: ReproducerInstrumentation.h:211
lldb::SBTypeSummaryOptions::SetOptions
void SetOptions(const lldb_private::TypeSummaryOptions *lldb_object_ptr)
Definition: SBTypeSummary.cpp:111
LLDB_RECORD_METHOD_CONST_NO_ARGS
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:168
lldb_private::CXXFunctionSummaryFormat
Definition: TypeSummary.h:306
lldb::SBStream::GetSize
size_t GetSize()
Definition: SBStream.cpp:54
lldb::SBTypeSummary::GetOptions
uint32_t GetOptions()
Definition: SBTypeSummary.cpp:260
lldb::SBTypeSummary::GetDescription
bool GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level)
Definition: SBTypeSummary.cpp:315
LLDB_RECORD_METHOD_NO_ARGS
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:165
lldb::SBTypeSummary::CreateWithCallback
static SBTypeSummary CreateWithCallback(FormatCallback cb, uint32_t options=0, const char *description=nullptr)
Definition: SBTypeSummary.cpp:162
lldb::SBValue
Definition: SBValue.h:21
lldb::SBTypeSummary::SetOptions
void SetOptions(uint32_t)
Definition: SBTypeSummary.cpp:268
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
LLDB_RECORD_CONSTRUCTOR_NO_ARGS
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
Definition: ReproducerInstrumentation.h:136
lldb::SBTypeSummaryOptions::SetLanguage
void SetLanguage(lldb::LanguageType)
Definition: SBTypeSummary.cpp:65
lldb::SBTypeSummary::IsEqualTo
bool IsEqualTo(lldb::SBTypeSummary &rhs)
Definition: SBTypeSummary.cpp:359
LLDB_REGISTER_METHOD_CONST
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:98
lldb::SBTypeSummaryOptions::SBTypeSummaryOptions
SBTypeSummaryOptions()
Definition: SBTypeSummary.cpp:21
lldb_private::Stream
Definition: Stream.h:28
SBReproducerPrivate.h
LLDB_REGISTER_CONSTRUCTOR
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
Definition: ReproducerInstrumentation.h:89
lldb::SBTypeSummary::CreateWithScriptCode
static SBTypeSummary CreateWithScriptCode(const char *data, uint32_t options=0)
Definition: SBTypeSummary.cpp:149
lldb::SBTypeSummary
Definition: SBTypeSummary.h:57
lldb::SBTypeSummary::operator==
bool operator==(lldb::SBTypeSummary &rhs)
Definition: SBTypeSummary.cpp:350
lldb::SBTypeSummary::~SBTypeSummary
~SBTypeSummary()
lldb::eTypeSummaryCapped
@ eTypeSummaryCapped
Definition: lldb-enumerations.h:1117
lldb::SBTypeSummary::operator=
lldb::SBTypeSummary & operator=(const lldb::SBTypeSummary &rhs)
Definition: SBTypeSummary.cpp:339
SBStream.h
LLDB_RECORD_METHOD
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:158
lldb::SBTypeSummary::GetData
const char * GetData()
Definition: SBTypeSummary.cpp:242
lldb_private::clone
std::unique_ptr< T > clone(const std::unique_ptr< T > &src)
Definition: Utils.h:17
Utils.h
lldb_private::ValueObject::GetSP
lldb::ValueObjectSP GetSP()
Definition: ValueObject.h:555
lldb::SBTypeSummary::CreateWithFunctionName
static SBTypeSummary CreateWithFunctionName(const char *data, uint32_t options=0)
Definition: SBTypeSummary.cpp:136
lldb::TypeSummaryCapping
TypeSummaryCapping
Whether a summary should cap how much data it returns to users or not.
Definition: lldb-enumerations.h:1116
lldb::SBTypeSummary::SetSummaryString
void SetSummaryString(const char *data)
Definition: SBTypeSummary.cpp:276
lldb::SBTypeSummaryOptions::~SBTypeSummaryOptions
~SBTypeSummaryOptions()
lldb::SBTypeSummary::operator!=
bool operator!=(lldb::SBTypeSummary &rhs)
Definition: SBTypeSummary.cpp:400
lldb_private::ScriptSummaryFormat
Definition: TypeSummary.h:352
lldb::SBTypeSummary::SetFunctionCode
void SetFunctionCode(const char *data)
Definition: SBTypeSummary.cpp:302
lldb_private::TypeSummaryImpl::Kind::eCallback
@ eCallback
LLDB_REGISTER_STATIC_METHOD
#define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:103
lldb::SBTypeSummaryOptions::GetCapping
lldb::TypeSummaryCapping GetCapping()
Definition: SBTypeSummary.cpp:56
lldb::SBTypeSummary::IsValid
bool IsValid() const
Definition: SBTypeSummary.cpp:197
lldb::SBTypeSummaryOptions::m_opaque_up
std::unique_ptr< lldb_private::TypeSummaryOptions > m_opaque_up
Definition: SBTypeSummary.h:54
LLDB_RECORD_CONSTRUCTOR
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
Definition: ReproducerInstrumentation.h:133
lldb::SBTypeSummaryOptions::SetCapping
void SetCapping(lldb::TypeSummaryCapping)
Definition: SBTypeSummary.cpp:73
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb::SBTypeSummary::DoesPrintValue
bool DoesPrintValue(lldb::SBValue value)
Definition: SBTypeSummary.cpp:329
lldb::SBTypeSummary::SBTypeSummary
SBTypeSummary()
Definition: SBTypeSummary.cpp:119
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
DataVisualization.h
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb::SBTypeSummaryOptions::IsValid
bool IsValid()
Definition: SBTypeSummary.cpp:37
uint32_t
lldb::SBTypeSummary::IsFunctionName
bool IsFunctionName()
Definition: SBTypeSummary.cpp:220
lldb::SBTypeSummary::m_opaque_sp
lldb::TypeSummaryImplSP m_opaque_sp
Definition: SBTypeSummary.h:128
lldb::SBTypeSummary::SetFunctionName
void SetFunctionName(const char *data)
Definition: SBTypeSummary.cpp:289
lldb_private::TypeSummaryOptions
Definition: TypeSummary.h:26
SBValue.h
lldb::SBTypeSummaryOptions
Definition: SBTypeSummary.h:16
lldb::SBTypeSummary::IsFunctionCode
bool IsFunctionCode()
Definition: SBTypeSummary.cpp:207
lldb::SBTypeSummaryOptions::operator->
lldb_private::TypeSummaryOptions * operator->()
Definition: SBTypeSummary.cpp:81
lldb::SBValue::GetSP
lldb::ValueObjectSP GetSP() const
Same as the protected version of GetSP that takes a locker, except that we make the locker locally in...
Definition: SBValue.cpp:1089
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::SBTypeSummaryOptions::get
lldb_private::TypeSummaryOptions * get()
Definition: SBTypeSummary.cpp:90
lldb_private::Stream::Write
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
Definition: Stream.h:101
LLDB_RECORD_STATIC_METHOD
#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:171
lldb_private::StringSummaryFormat
Definition: TypeSummary.h:278
lldb::SBTypeSummaryOptions::ref
lldb_private::TypeSummaryOptions & ref()
Definition: SBTypeSummary.cpp:94
LLDB_RECORD_DUMMY
#define LLDB_RECORD_DUMMY(Result, Class, Method, Signature,...)
The LLDB_RECORD_DUMMY macro is special because it doesn't actually record anything.
Definition: ReproducerInstrumentation.h:216
lldb::SBStream
Definition: SBStream.h:18
lldb::SBTypeSummary::ChangeSummaryType
bool ChangeSummaryType(bool want_script)
Definition: SBTypeSummary.cpp:448
lldb::SBTypeSummary::CopyOnWrite_Impl
bool CopyOnWrite_Impl()
Definition: SBTypeSummary.cpp:418
lldb
Definition: SBAddress.h:15
lldb_private::repro::RegisterMethods< SBTypeSummaryOptions >
void RegisterMethods< SBTypeSummaryOptions >(Registry &R)
Definition: SBTypeSummary.cpp:480
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::SBStream::GetData
const char * GetData()
Definition: SBStream.cpp:43
LLDB_REGISTER_METHOD
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:93