1 //===-- SBValue.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 "lldb/lldb-python.h"
11
12 #include "lldb/API/SBValue.h"
13
14 #include "lldb/API/SBDeclaration.h"
15 #include "lldb/API/SBStream.h"
16 #include "lldb/API/SBTypeFilter.h"
17 #include "lldb/API/SBTypeFormat.h"
18 #include "lldb/API/SBTypeSummary.h"
19 #include "lldb/API/SBTypeSynthetic.h"
20
21 #include "lldb/Breakpoint/Watchpoint.h"
22 #include "lldb/Core/DataExtractor.h"
23 #include "lldb/Core/Log.h"
24 #include "lldb/Core/Module.h"
25 #include "lldb/Core/Scalar.h"
26 #include "lldb/Core/Section.h"
27 #include "lldb/Core/Stream.h"
28 #include "lldb/Core/StreamFile.h"
29 #include "lldb/Core/Value.h"
30 #include "lldb/Core/ValueObject.h"
31 #include "lldb/Core/ValueObjectConstResult.h"
32 #include "lldb/DataFormatters/DataVisualization.h"
33 #include "lldb/Symbol/Block.h"
34 #include "lldb/Symbol/Declaration.h"
35 #include "lldb/Symbol/ObjectFile.h"
36 #include "lldb/Symbol/Type.h"
37 #include "lldb/Symbol/Variable.h"
38 #include "lldb/Symbol/VariableList.h"
39 #include "lldb/Target/ExecutionContext.h"
40 #include "lldb/Target/Process.h"
41 #include "lldb/Target/StackFrame.h"
42 #include "lldb/Target/Target.h"
43 #include "lldb/Target/Thread.h"
44
45 #include "lldb/API/SBDebugger.h"
46 #include "lldb/API/SBExpressionOptions.h"
47 #include "lldb/API/SBFrame.h"
48 #include "lldb/API/SBProcess.h"
49 #include "lldb/API/SBTarget.h"
50 #include "lldb/API/SBThread.h"
51
52 using namespace lldb;
53 using namespace lldb_private;
54
55 class ValueImpl
56 {
57 public:
ValueImpl()58 ValueImpl ()
59 {
60 }
61
ValueImpl(lldb::ValueObjectSP in_valobj_sp,lldb::DynamicValueType use_dynamic,bool use_synthetic,const char * name=NULL)62 ValueImpl (lldb::ValueObjectSP in_valobj_sp,
63 lldb::DynamicValueType use_dynamic,
64 bool use_synthetic,
65 const char *name = NULL) :
66 m_valobj_sp(in_valobj_sp),
67 m_use_dynamic(use_dynamic),
68 m_use_synthetic(use_synthetic),
69 m_name (name)
70 {
71 if (!m_name.IsEmpty() && m_valobj_sp)
72 m_valobj_sp->SetName(m_name);
73 }
74
ValueImpl(const ValueImpl & rhs)75 ValueImpl (const ValueImpl& rhs) :
76 m_valobj_sp(rhs.m_valobj_sp),
77 m_use_dynamic(rhs.m_use_dynamic),
78 m_use_synthetic(rhs.m_use_synthetic),
79 m_name (rhs.m_name)
80 {
81 }
82
83 ValueImpl &
operator =(const ValueImpl & rhs)84 operator = (const ValueImpl &rhs)
85 {
86 if (this != &rhs)
87 {
88 m_valobj_sp = rhs.m_valobj_sp;
89 m_use_dynamic = rhs.m_use_dynamic;
90 m_use_synthetic = rhs.m_use_synthetic;
91 m_name = rhs.m_name;
92 }
93 return *this;
94 }
95
96 bool
IsValid()97 IsValid ()
98 {
99 if (m_valobj_sp.get() == NULL)
100 return false;
101 else
102 {
103 // FIXME: This check is necessary but not sufficient. We for sure don't want to touch SBValues whose owning
104 // targets have gone away. This check is a little weak in that it enforces that restriction when you call
105 // IsValid, but since IsValid doesn't lock the target, you have no guarantee that the SBValue won't go
106 // invalid after you call this...
107 // Also, an SBValue could depend on data from one of the modules in the target, and those could go away
108 // independently of the target, for instance if a module is unloaded. But right now, neither SBValues
109 // nor ValueObjects know which modules they depend on. So I have no good way to make that check without
110 // tracking that in all the ValueObject subclasses.
111 TargetSP target_sp = m_valobj_sp->GetTargetSP();
112 if (target_sp && target_sp->IsValid())
113 return true;
114 else
115 return false;
116 }
117 }
118
119 lldb::ValueObjectSP
GetRootSP()120 GetRootSP ()
121 {
122 return m_valobj_sp;
123 }
124
125 lldb::ValueObjectSP
GetSP(Process::StopLocker & stop_locker,Mutex::Locker & api_locker,Error & error)126 GetSP (Process::StopLocker &stop_locker, Mutex::Locker &api_locker, Error &error)
127 {
128 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
129 if (!m_valobj_sp)
130 {
131 error.SetErrorString("invalid value object");
132 return m_valobj_sp;
133 }
134
135 lldb::ValueObjectSP value_sp = m_valobj_sp;
136
137 Target *target = value_sp->GetTargetSP().get();
138 if (target)
139 api_locker.Lock(target->GetAPIMutex());
140 else
141 return ValueObjectSP();
142
143 ProcessSP process_sp(value_sp->GetProcessSP());
144 if (process_sp && !stop_locker.TryLock (&process_sp->GetRunLock()))
145 {
146 // We don't allow people to play around with ValueObject if the process is running.
147 // If you want to look at values, pause the process, then look.
148 if (log)
149 log->Printf ("SBValue(%p)::GetSP() => error: process is running", value_sp.get());
150 error.SetErrorString ("process must be stopped.");
151 return ValueObjectSP();
152 }
153
154 if (value_sp->GetDynamicValue(m_use_dynamic))
155 value_sp = value_sp->GetDynamicValue(m_use_dynamic);
156 if (value_sp->GetSyntheticValue(m_use_synthetic))
157 value_sp = value_sp->GetSyntheticValue(m_use_synthetic);
158 if (!value_sp)
159 error.SetErrorString("invalid value object");
160 if (!m_name.IsEmpty())
161 value_sp->SetName(m_name);
162
163 return value_sp;
164 }
165
166 void
SetUseDynamic(lldb::DynamicValueType use_dynamic)167 SetUseDynamic (lldb::DynamicValueType use_dynamic)
168 {
169 m_use_dynamic = use_dynamic;
170 }
171
172 void
SetUseSynthetic(bool use_synthetic)173 SetUseSynthetic (bool use_synthetic)
174 {
175 m_use_synthetic = use_synthetic;
176 }
177
178 lldb::DynamicValueType
GetUseDynamic()179 GetUseDynamic ()
180 {
181 return m_use_dynamic;
182 }
183
184 bool
GetUseSynthetic()185 GetUseSynthetic ()
186 {
187 return m_use_synthetic;
188 }
189
190 // All the derived values that we would make from the m_valobj_sp will share
191 // the ExecutionContext with m_valobj_sp, so we don't need to do the calculations
192 // in GetSP to return the Target, Process, Thread or Frame. It is convenient to
193 // provide simple accessors for these, which I do here.
194 TargetSP
GetTargetSP()195 GetTargetSP ()
196 {
197 if (m_valobj_sp)
198 return m_valobj_sp->GetTargetSP();
199 else
200 return TargetSP();
201 }
202
203 ProcessSP
GetProcessSP()204 GetProcessSP ()
205 {
206 if (m_valobj_sp)
207 return m_valobj_sp->GetProcessSP();
208 else
209 return ProcessSP();
210 }
211
212 ThreadSP
GetThreadSP()213 GetThreadSP ()
214 {
215 if (m_valobj_sp)
216 return m_valobj_sp->GetThreadSP();
217 else
218 return ThreadSP();
219 }
220
221 StackFrameSP
GetFrameSP()222 GetFrameSP ()
223 {
224 if (m_valobj_sp)
225 return m_valobj_sp->GetFrameSP();
226 else
227 return StackFrameSP();
228 }
229
230 private:
231 lldb::ValueObjectSP m_valobj_sp;
232 lldb::DynamicValueType m_use_dynamic;
233 bool m_use_synthetic;
234 ConstString m_name;
235 };
236
237 class ValueLocker
238 {
239 public:
ValueLocker()240 ValueLocker ()
241 {
242 }
243
244 ValueObjectSP
GetLockedSP(ValueImpl & in_value)245 GetLockedSP(ValueImpl &in_value)
246 {
247 return in_value.GetSP(m_stop_locker, m_api_locker, m_lock_error);
248 }
249
250 Error &
GetError()251 GetError()
252 {
253 return m_lock_error;
254 }
255
256 private:
257 Process::StopLocker m_stop_locker;
258 Mutex::Locker m_api_locker;
259 Error m_lock_error;
260
261 };
262
SBValue()263 SBValue::SBValue () :
264 m_opaque_sp ()
265 {
266 }
267
SBValue(const lldb::ValueObjectSP & value_sp)268 SBValue::SBValue (const lldb::ValueObjectSP &value_sp)
269 {
270 SetSP(value_sp);
271 }
272
SBValue(const SBValue & rhs)273 SBValue::SBValue(const SBValue &rhs)
274 {
275 SetSP(rhs.m_opaque_sp);
276 }
277
278 SBValue &
operator =(const SBValue & rhs)279 SBValue::operator = (const SBValue &rhs)
280 {
281 if (this != &rhs)
282 {
283 SetSP(rhs.m_opaque_sp);
284 }
285 return *this;
286 }
287
~SBValue()288 SBValue::~SBValue()
289 {
290 }
291
292 bool
IsValid()293 SBValue::IsValid ()
294 {
295 // If this function ever changes to anything that does more than just
296 // check if the opaque shared pointer is non NULL, then we need to update
297 // all "if (m_opaque_sp)" code in this file.
298 return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() && m_opaque_sp->GetRootSP().get() != NULL;
299 }
300
301 void
Clear()302 SBValue::Clear()
303 {
304 m_opaque_sp.reset();
305 }
306
307 SBError
GetError()308 SBValue::GetError()
309 {
310 SBError sb_error;
311
312 ValueLocker locker;
313 lldb::ValueObjectSP value_sp(GetSP(locker));
314 if (value_sp)
315 sb_error.SetError(value_sp->GetError());
316 else
317 sb_error.SetErrorStringWithFormat ("error: %s", locker.GetError().AsCString());
318
319 return sb_error;
320 }
321
322 user_id_t
GetID()323 SBValue::GetID()
324 {
325 ValueLocker locker;
326 lldb::ValueObjectSP value_sp(GetSP(locker));
327 if (value_sp)
328 return value_sp->GetID();
329 return LLDB_INVALID_UID;
330 }
331
332 const char *
GetName()333 SBValue::GetName()
334 {
335 const char *name = NULL;
336 ValueLocker locker;
337 lldb::ValueObjectSP value_sp(GetSP(locker));
338 if (value_sp)
339 name = value_sp->GetName().GetCString();
340
341 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
342 if (log)
343 {
344 if (name)
345 log->Printf ("SBValue(%p)::GetName () => \"%s\"", value_sp.get(), name);
346 else
347 log->Printf ("SBValue(%p)::GetName () => NULL", value_sp.get());
348 }
349
350 return name;
351 }
352
353 const char *
GetTypeName()354 SBValue::GetTypeName ()
355 {
356 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
357 const char *name = NULL;
358 ValueLocker locker;
359 lldb::ValueObjectSP value_sp(GetSP(locker));
360 if (value_sp)
361 {
362 name = value_sp->GetQualifiedTypeName().GetCString();
363 }
364
365 if (log)
366 {
367 if (name)
368 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", value_sp.get(), name);
369 else
370 log->Printf ("SBValue(%p)::GetTypeName () => NULL", value_sp.get());
371 }
372
373 return name;
374 }
375
376 size_t
GetByteSize()377 SBValue::GetByteSize ()
378 {
379 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
380 size_t result = 0;
381
382 ValueLocker locker;
383 lldb::ValueObjectSP value_sp(GetSP(locker));
384 if (value_sp)
385 {
386 result = value_sp->GetByteSize();
387 }
388
389 if (log)
390 log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64, value_sp.get(), (uint64_t)result);
391
392 return result;
393 }
394
395 bool
IsInScope()396 SBValue::IsInScope ()
397 {
398 bool result = false;
399
400 ValueLocker locker;
401 lldb::ValueObjectSP value_sp(GetSP(locker));
402 if (value_sp)
403 {
404 result = value_sp->IsInScope ();
405 }
406
407 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
408 if (log)
409 log->Printf ("SBValue(%p)::IsInScope () => %i", value_sp.get(), result);
410
411 return result;
412 }
413
414 const char *
GetValue()415 SBValue::GetValue ()
416 {
417 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
418
419 const char *cstr = NULL;
420 ValueLocker locker;
421 lldb::ValueObjectSP value_sp(GetSP(locker));
422 if (value_sp)
423 {
424 cstr = value_sp->GetValueAsCString ();
425 }
426 if (log)
427 {
428 if (cstr)
429 log->Printf ("SBValue(%p)::GetValue() => \"%s\"", value_sp.get(), cstr);
430 else
431 log->Printf ("SBValue(%p)::GetValue() => NULL", value_sp.get());
432 }
433
434 return cstr;
435 }
436
437 ValueType
GetValueType()438 SBValue::GetValueType ()
439 {
440 ValueType result = eValueTypeInvalid;
441 ValueLocker locker;
442 lldb::ValueObjectSP value_sp(GetSP(locker));
443 if (value_sp)
444 result = value_sp->GetValueType();
445
446 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
447 if (log)
448 {
449 switch (result)
450 {
451 case eValueTypeInvalid: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", value_sp.get()); break;
452 case eValueTypeVariableGlobal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", value_sp.get()); break;
453 case eValueTypeVariableStatic: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", value_sp.get()); break;
454 case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", value_sp.get()); break;
455 case eValueTypeVariableLocal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", value_sp.get()); break;
456 case eValueTypeRegister: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", value_sp.get()); break;
457 case eValueTypeRegisterSet: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", value_sp.get()); break;
458 case eValueTypeConstResult: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", value_sp.get()); break;
459 }
460 }
461 return result;
462 }
463
464 const char *
GetObjectDescription()465 SBValue::GetObjectDescription ()
466 {
467 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
468 const char *cstr = NULL;
469 ValueLocker locker;
470 lldb::ValueObjectSP value_sp(GetSP(locker));
471 if (value_sp)
472 {
473 cstr = value_sp->GetObjectDescription ();
474 }
475 if (log)
476 {
477 if (cstr)
478 log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"", value_sp.get(), cstr);
479 else
480 log->Printf ("SBValue(%p)::GetObjectDescription() => NULL", value_sp.get());
481 }
482 return cstr;
483 }
484
485 SBType
GetType()486 SBValue::GetType()
487 {
488 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
489 SBType sb_type;
490 ValueLocker locker;
491 lldb::ValueObjectSP value_sp(GetSP(locker));
492 TypeImplSP type_sp;
493 if (value_sp)
494 {
495 type_sp.reset (new TypeImpl(value_sp->GetTypeImpl()));
496 sb_type.SetSP(type_sp);
497 }
498 if (log)
499 {
500 if (type_sp)
501 log->Printf ("SBValue(%p)::GetType => SBType(%p)", value_sp.get(), type_sp.get());
502 else
503 log->Printf ("SBValue(%p)::GetType => NULL", value_sp.get());
504 }
505 return sb_type;
506 }
507
508 bool
GetValueDidChange()509 SBValue::GetValueDidChange ()
510 {
511 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
512 bool result = false;
513 ValueLocker locker;
514 lldb::ValueObjectSP value_sp(GetSP(locker));
515 if (value_sp)
516 {
517 result = value_sp->GetValueDidChange ();
518 }
519 if (log)
520 log->Printf ("SBValue(%p)::GetValueDidChange() => %i", value_sp.get(), result);
521
522 return result;
523 }
524
525 #ifndef LLDB_DISABLE_PYTHON
526 const char *
GetSummary()527 SBValue::GetSummary ()
528 {
529 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
530 const char *cstr = NULL;
531 ValueLocker locker;
532 lldb::ValueObjectSP value_sp(GetSP(locker));
533 if (value_sp)
534 {
535 cstr = value_sp->GetSummaryAsCString();
536 }
537 if (log)
538 {
539 if (cstr)
540 log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", value_sp.get(), cstr);
541 else
542 log->Printf ("SBValue(%p)::GetSummary() => NULL", value_sp.get());
543 }
544 return cstr;
545 }
546 #endif // LLDB_DISABLE_PYTHON
547
548 const char *
GetLocation()549 SBValue::GetLocation ()
550 {
551 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
552 const char *cstr = NULL;
553 ValueLocker locker;
554 lldb::ValueObjectSP value_sp(GetSP(locker));
555 if (value_sp)
556 {
557 cstr = value_sp->GetLocationAsCString();
558 }
559 if (log)
560 {
561 if (cstr)
562 log->Printf ("SBValue(%p)::GetLocation() => \"%s\"", value_sp.get(), cstr);
563 else
564 log->Printf ("SBValue(%p)::GetLocation() => NULL", value_sp.get());
565 }
566 return cstr;
567 }
568
569 // Deprecated - use the one that takes an lldb::SBError
570 bool
SetValueFromCString(const char * value_str)571 SBValue::SetValueFromCString (const char *value_str)
572 {
573 lldb::SBError dummy;
574 return SetValueFromCString(value_str,dummy);
575 }
576
577 bool
SetValueFromCString(const char * value_str,lldb::SBError & error)578 SBValue::SetValueFromCString (const char *value_str, lldb::SBError& error)
579 {
580 bool success = false;
581 ValueLocker locker;
582 lldb::ValueObjectSP value_sp(GetSP(locker));
583 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
584 if (value_sp)
585 {
586 success = value_sp->SetValueFromCString (value_str,error.ref());
587 }
588 else
589 error.SetErrorStringWithFormat ("Could not get value: %s", locker.GetError().AsCString());
590
591 if (log)
592 log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i", value_sp.get(), value_str, success);
593
594 return success;
595 }
596
597 lldb::SBTypeFormat
GetTypeFormat()598 SBValue::GetTypeFormat ()
599 {
600 lldb::SBTypeFormat format;
601 ValueLocker locker;
602 lldb::ValueObjectSP value_sp(GetSP(locker));
603 if (value_sp)
604 {
605 if (value_sp->UpdateValueIfNeeded(true))
606 {
607 lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
608 if (format_sp)
609 format.SetSP(format_sp);
610 }
611 }
612 return format;
613 }
614
615 #ifndef LLDB_DISABLE_PYTHON
616 lldb::SBTypeSummary
GetTypeSummary()617 SBValue::GetTypeSummary ()
618 {
619 lldb::SBTypeSummary summary;
620 ValueLocker locker;
621 lldb::ValueObjectSP value_sp(GetSP(locker));
622 if (value_sp)
623 {
624 if (value_sp->UpdateValueIfNeeded(true))
625 {
626 lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
627 if (summary_sp)
628 summary.SetSP(summary_sp);
629 }
630 }
631 return summary;
632 }
633 #endif // LLDB_DISABLE_PYTHON
634
635 lldb::SBTypeFilter
GetTypeFilter()636 SBValue::GetTypeFilter ()
637 {
638 lldb::SBTypeFilter filter;
639 ValueLocker locker;
640 lldb::ValueObjectSP value_sp(GetSP(locker));
641 if (value_sp)
642 {
643 if (value_sp->UpdateValueIfNeeded(true))
644 {
645 lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
646
647 if (synthetic_sp && !synthetic_sp->IsScripted())
648 {
649 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
650 filter.SetSP(filter_sp);
651 }
652 }
653 }
654 return filter;
655 }
656
657 #ifndef LLDB_DISABLE_PYTHON
658 lldb::SBTypeSynthetic
GetTypeSynthetic()659 SBValue::GetTypeSynthetic ()
660 {
661 lldb::SBTypeSynthetic synthetic;
662 ValueLocker locker;
663 lldb::ValueObjectSP value_sp(GetSP(locker));
664 if (value_sp)
665 {
666 if (value_sp->UpdateValueIfNeeded(true))
667 {
668 lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
669
670 if (children_sp && children_sp->IsScripted())
671 {
672 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
673 synthetic.SetSP(synth_sp);
674 }
675 }
676 }
677 return synthetic;
678 }
679 #endif
680
681 lldb::SBValue
CreateChildAtOffset(const char * name,uint32_t offset,SBType type)682 SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type)
683 {
684 lldb::SBValue sb_value;
685 ValueLocker locker;
686 lldb::ValueObjectSP value_sp(GetSP(locker));
687 lldb::ValueObjectSP new_value_sp;
688 if (value_sp)
689 {
690 TypeImplSP type_sp (type.GetSP());
691 if (type.IsValid())
692 {
693 sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetClangASTType(false), true),GetPreferDynamicValue(),GetPreferSyntheticValue(), name);
694 }
695 }
696 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
697 if (log)
698 {
699 if (new_value_sp)
700 log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"",
701 value_sp.get(),
702 new_value_sp->GetName().AsCString());
703 else
704 log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL",
705 value_sp.get());
706 }
707 return sb_value;
708 }
709
710 lldb::SBValue
Cast(SBType type)711 SBValue::Cast (SBType type)
712 {
713 lldb::SBValue sb_value;
714 ValueLocker locker;
715 lldb::ValueObjectSP value_sp(GetSP(locker));
716 TypeImplSP type_sp (type.GetSP());
717 if (value_sp && type_sp)
718 sb_value.SetSP(value_sp->Cast(type_sp->GetClangASTType(false)),GetPreferDynamicValue(),GetPreferSyntheticValue());
719 return sb_value;
720 }
721
722 lldb::SBValue
CreateValueFromExpression(const char * name,const char * expression)723 SBValue::CreateValueFromExpression (const char *name, const char* expression)
724 {
725 SBExpressionOptions options;
726 options.ref().SetKeepInMemory(true);
727 return CreateValueFromExpression (name, expression, options);
728 }
729
730 lldb::SBValue
CreateValueFromExpression(const char * name,const char * expression,SBExpressionOptions & options)731 SBValue::CreateValueFromExpression (const char *name, const char *expression, SBExpressionOptions &options)
732 {
733 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
734 lldb::SBValue sb_value;
735 ValueLocker locker;
736 lldb::ValueObjectSP value_sp(GetSP(locker));
737 lldb::ValueObjectSP new_value_sp;
738 if (value_sp)
739 {
740 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
741 Target* target = exe_ctx.GetTargetPtr();
742 if (target)
743 {
744 options.ref().SetKeepInMemory(true);
745 target->EvaluateExpression (expression,
746 exe_ctx.GetFramePtr(),
747 new_value_sp,
748 options.ref());
749 if (new_value_sp)
750 {
751 new_value_sp->SetName(ConstString(name));
752 sb_value.SetSP(new_value_sp);
753 }
754 }
755 }
756 if (log)
757 {
758 if (new_value_sp)
759 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => SBValue (%p)",
760 value_sp.get(),
761 name,
762 expression,
763 new_value_sp.get());
764 else
765 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL",
766 value_sp.get(),
767 name,
768 expression);
769 }
770 return sb_value;
771 }
772
773 lldb::SBValue
CreateValueFromAddress(const char * name,lldb::addr_t address,SBType sb_type)774 SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type)
775 {
776 lldb::SBValue sb_value;
777 ValueLocker locker;
778 lldb::ValueObjectSP value_sp(GetSP(locker));
779 lldb::ValueObjectSP new_value_sp;
780 lldb::TypeImplSP type_impl_sp (sb_type.GetSP());
781 if (value_sp && type_impl_sp)
782 {
783 ClangASTType pointer_ast_type(type_impl_sp->GetClangASTType(false).GetPointerType ());
784 if (pointer_ast_type)
785 {
786 lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
787
788 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
789 ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
790 pointer_ast_type,
791 ConstString(name),
792 buffer,
793 exe_ctx.GetByteOrder(),
794 exe_ctx.GetAddressByteSize()));
795
796 if (ptr_result_valobj_sp)
797 {
798 ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
799 Error err;
800 new_value_sp = ptr_result_valobj_sp->Dereference(err);
801 if (new_value_sp)
802 new_value_sp->SetName(ConstString(name));
803 }
804 sb_value.SetSP(new_value_sp);
805 }
806 }
807 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
808 if (log)
809 {
810 if (new_value_sp)
811 log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString());
812 else
813 log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", value_sp.get());
814 }
815 return sb_value;
816 }
817
818 lldb::SBValue
CreateValueFromData(const char * name,SBData data,SBType type)819 SBValue::CreateValueFromData (const char* name, SBData data, SBType type)
820 {
821 lldb::SBValue sb_value;
822 lldb::ValueObjectSP new_value_sp;
823 ValueLocker locker;
824 lldb::ValueObjectSP value_sp(GetSP(locker));
825 if (value_sp)
826 {
827 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
828
829 new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
830 type.m_opaque_sp->GetClangASTType(false),
831 ConstString(name),
832 *data.m_opaque_sp,
833 LLDB_INVALID_ADDRESS);
834 new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
835 sb_value.SetSP(new_value_sp);
836 }
837 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
838 if (log)
839 {
840 if (new_value_sp)
841 log->Printf ("SBValue(%p)::CreateValueFromData => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString());
842 else
843 log->Printf ("SBValue(%p)::CreateValueFromData => NULL", value_sp.get());
844 }
845 return sb_value;
846 }
847
848 SBValue
GetChildAtIndex(uint32_t idx)849 SBValue::GetChildAtIndex (uint32_t idx)
850 {
851 const bool can_create_synthetic = false;
852 lldb::DynamicValueType use_dynamic = eNoDynamicValues;
853 TargetSP target_sp;
854 if (m_opaque_sp)
855 target_sp = m_opaque_sp->GetTargetSP();
856
857 if (target_sp)
858 use_dynamic = target_sp->GetPreferDynamicValue();
859
860 return GetChildAtIndex (idx, use_dynamic, can_create_synthetic);
861 }
862
863 SBValue
GetChildAtIndex(uint32_t idx,lldb::DynamicValueType use_dynamic,bool can_create_synthetic)864 SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic)
865 {
866 lldb::ValueObjectSP child_sp;
867 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
868
869 ValueLocker locker;
870 lldb::ValueObjectSP value_sp(GetSP(locker));
871 if (value_sp)
872 {
873 const bool can_create = true;
874 child_sp = value_sp->GetChildAtIndex (idx, can_create);
875 if (can_create_synthetic && !child_sp)
876 {
877 if (value_sp->IsPointerType())
878 {
879 child_sp = value_sp->GetSyntheticArrayMemberFromPointer(idx, can_create);
880 }
881 else if (value_sp->IsArrayType())
882 {
883 child_sp = value_sp->GetSyntheticArrayMemberFromArray(idx, can_create);
884 }
885 }
886 }
887
888 SBValue sb_value;
889 sb_value.SetSP (child_sp, use_dynamic, GetPreferSyntheticValue());
890 if (log)
891 log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", value_sp.get(), idx, value_sp.get());
892
893 return sb_value;
894 }
895
896 uint32_t
GetIndexOfChildWithName(const char * name)897 SBValue::GetIndexOfChildWithName (const char *name)
898 {
899 uint32_t idx = UINT32_MAX;
900 ValueLocker locker;
901 lldb::ValueObjectSP value_sp(GetSP(locker));
902 if (value_sp)
903 {
904 idx = value_sp->GetIndexOfChildWithName (ConstString(name));
905 }
906 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
907 if (log)
908 {
909 if (idx == UINT32_MAX)
910 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", value_sp.get(), name);
911 else
912 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", value_sp.get(), name, idx);
913 }
914 return idx;
915 }
916
917 SBValue
GetChildMemberWithName(const char * name)918 SBValue::GetChildMemberWithName (const char *name)
919 {
920 lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
921 TargetSP target_sp;
922 if (m_opaque_sp)
923 target_sp = m_opaque_sp->GetTargetSP();
924
925 if (target_sp)
926 use_dynamic_value = target_sp->GetPreferDynamicValue();
927 return GetChildMemberWithName (name, use_dynamic_value);
928 }
929
930 SBValue
GetChildMemberWithName(const char * name,lldb::DynamicValueType use_dynamic_value)931 SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value)
932 {
933 lldb::ValueObjectSP child_sp;
934 const ConstString str_name (name);
935
936 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
937
938 ValueLocker locker;
939 lldb::ValueObjectSP value_sp(GetSP(locker));
940 if (value_sp)
941 {
942 child_sp = value_sp->GetChildMemberWithName (str_name, true);
943 }
944
945 SBValue sb_value;
946 sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
947
948 if (log)
949 log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", value_sp.get(), name, value_sp.get());
950
951 return sb_value;
952 }
953
954 lldb::SBValue
GetDynamicValue(lldb::DynamicValueType use_dynamic)955 SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic)
956 {
957 SBValue value_sb;
958 if (IsValid())
959 {
960 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),use_dynamic,m_opaque_sp->GetUseSynthetic()));
961 value_sb.SetSP(proxy_sp);
962 }
963 return value_sb;
964 }
965
966 lldb::SBValue
GetStaticValue()967 SBValue::GetStaticValue ()
968 {
969 SBValue value_sb;
970 if (IsValid())
971 {
972 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),eNoDynamicValues,m_opaque_sp->GetUseSynthetic()));
973 value_sb.SetSP(proxy_sp);
974 }
975 return value_sb;
976 }
977
978 lldb::SBValue
GetNonSyntheticValue()979 SBValue::GetNonSyntheticValue ()
980 {
981 SBValue value_sb;
982 if (IsValid())
983 {
984 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),m_opaque_sp->GetUseDynamic(),false));
985 value_sb.SetSP(proxy_sp);
986 }
987 return value_sb;
988 }
989
990 lldb::DynamicValueType
GetPreferDynamicValue()991 SBValue::GetPreferDynamicValue ()
992 {
993 if (!IsValid())
994 return eNoDynamicValues;
995 return m_opaque_sp->GetUseDynamic();
996 }
997
998 void
SetPreferDynamicValue(lldb::DynamicValueType use_dynamic)999 SBValue::SetPreferDynamicValue (lldb::DynamicValueType use_dynamic)
1000 {
1001 if (IsValid())
1002 return m_opaque_sp->SetUseDynamic (use_dynamic);
1003 }
1004
1005 bool
GetPreferSyntheticValue()1006 SBValue::GetPreferSyntheticValue ()
1007 {
1008 if (!IsValid())
1009 return false;
1010 return m_opaque_sp->GetUseSynthetic();
1011 }
1012
1013 void
SetPreferSyntheticValue(bool use_synthetic)1014 SBValue::SetPreferSyntheticValue (bool use_synthetic)
1015 {
1016 if (IsValid())
1017 return m_opaque_sp->SetUseSynthetic (use_synthetic);
1018 }
1019
1020 bool
IsDynamic()1021 SBValue::IsDynamic()
1022 {
1023 ValueLocker locker;
1024 lldb::ValueObjectSP value_sp(GetSP(locker));
1025 if (value_sp)
1026 return value_sp->IsDynamic();
1027 return false;
1028 }
1029
1030 bool
IsSynthetic()1031 SBValue::IsSynthetic ()
1032 {
1033 ValueLocker locker;
1034 lldb::ValueObjectSP value_sp(GetSP(locker));
1035 if (value_sp)
1036 return value_sp->IsSynthetic();
1037 return false;
1038 }
1039
1040 lldb::SBValue
GetValueForExpressionPath(const char * expr_path)1041 SBValue::GetValueForExpressionPath(const char* expr_path)
1042 {
1043 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1044 lldb::ValueObjectSP child_sp;
1045 ValueLocker locker;
1046 lldb::ValueObjectSP value_sp(GetSP(locker));
1047 if (value_sp)
1048 {
1049 // using default values for all the fancy options, just do it if you can
1050 child_sp = value_sp->GetValueForExpressionPath(expr_path);
1051 }
1052
1053 SBValue sb_value;
1054 sb_value.SetSP(child_sp,GetPreferDynamicValue(),GetPreferSyntheticValue());
1055
1056 if (log)
1057 log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", value_sp.get(), expr_path, value_sp.get());
1058
1059 return sb_value;
1060 }
1061
1062 int64_t
GetValueAsSigned(SBError & error,int64_t fail_value)1063 SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
1064 {
1065 error.Clear();
1066 ValueLocker locker;
1067 lldb::ValueObjectSP value_sp(GetSP(locker));
1068 if (value_sp)
1069 {
1070 bool success = true;
1071 uint64_t ret_val = fail_value;
1072 ret_val = value_sp->GetValueAsSigned(fail_value, &success);
1073 if (!success)
1074 error.SetErrorString("could not resolve value");
1075 return ret_val;
1076 }
1077 else
1078 error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString());
1079
1080 return fail_value;
1081 }
1082
1083 uint64_t
GetValueAsUnsigned(SBError & error,uint64_t fail_value)1084 SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value)
1085 {
1086 error.Clear();
1087 ValueLocker locker;
1088 lldb::ValueObjectSP value_sp(GetSP(locker));
1089 if (value_sp)
1090 {
1091 bool success = true;
1092 uint64_t ret_val = fail_value;
1093 ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
1094 if (!success)
1095 error.SetErrorString("could not resolve value");
1096 return ret_val;
1097 }
1098 else
1099 error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString());
1100
1101 return fail_value;
1102 }
1103
1104 int64_t
GetValueAsSigned(int64_t fail_value)1105 SBValue::GetValueAsSigned(int64_t fail_value)
1106 {
1107 ValueLocker locker;
1108 lldb::ValueObjectSP value_sp(GetSP(locker));
1109 if (value_sp)
1110 {
1111 return value_sp->GetValueAsSigned(fail_value);
1112 }
1113 return fail_value;
1114 }
1115
1116 uint64_t
GetValueAsUnsigned(uint64_t fail_value)1117 SBValue::GetValueAsUnsigned(uint64_t fail_value)
1118 {
1119 ValueLocker locker;
1120 lldb::ValueObjectSP value_sp(GetSP(locker));
1121 if (value_sp)
1122 {
1123 return value_sp->GetValueAsUnsigned(fail_value);
1124 }
1125 return fail_value;
1126 }
1127
1128 bool
MightHaveChildren()1129 SBValue::MightHaveChildren ()
1130 {
1131 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1132 bool has_children = false;
1133 ValueLocker locker;
1134 lldb::ValueObjectSP value_sp(GetSP(locker));
1135 if (value_sp)
1136 has_children = value_sp->MightHaveChildren();
1137
1138 if (log)
1139 log->Printf ("SBValue(%p)::MightHaveChildren() => %i", value_sp.get(), has_children);
1140 return has_children;
1141 }
1142
1143 uint32_t
GetNumChildren()1144 SBValue::GetNumChildren ()
1145 {
1146 uint32_t num_children = 0;
1147
1148 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1149 ValueLocker locker;
1150 lldb::ValueObjectSP value_sp(GetSP(locker));
1151 if (value_sp)
1152 num_children = value_sp->GetNumChildren();
1153
1154 if (log)
1155 log->Printf ("SBValue(%p)::GetNumChildren () => %u", value_sp.get(), num_children);
1156
1157 return num_children;
1158 }
1159
1160
1161 SBValue
Dereference()1162 SBValue::Dereference ()
1163 {
1164 SBValue sb_value;
1165 ValueLocker locker;
1166 lldb::ValueObjectSP value_sp(GetSP(locker));
1167 if (value_sp)
1168 {
1169 Error error;
1170 sb_value = value_sp->Dereference (error);
1171 }
1172 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1173 if (log)
1174 log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", value_sp.get(), value_sp.get());
1175
1176 return sb_value;
1177 }
1178
1179 bool
TypeIsPointerType()1180 SBValue::TypeIsPointerType ()
1181 {
1182 bool is_ptr_type = false;
1183
1184 ValueLocker locker;
1185 lldb::ValueObjectSP value_sp(GetSP(locker));
1186 if (value_sp)
1187 is_ptr_type = value_sp->IsPointerType();
1188
1189 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1190 if (log)
1191 log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", value_sp.get(), is_ptr_type);
1192
1193
1194 return is_ptr_type;
1195 }
1196
1197 void *
GetOpaqueType()1198 SBValue::GetOpaqueType()
1199 {
1200 ValueLocker locker;
1201 lldb::ValueObjectSP value_sp(GetSP(locker));
1202 if (value_sp)
1203 return value_sp->GetClangType().GetOpaqueQualType();
1204 return NULL;
1205 }
1206
1207 lldb::SBTarget
GetTarget()1208 SBValue::GetTarget()
1209 {
1210 SBTarget sb_target;
1211 TargetSP target_sp;
1212 if (m_opaque_sp)
1213 {
1214 target_sp = m_opaque_sp->GetTargetSP();
1215 sb_target.SetSP (target_sp);
1216 }
1217 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1218 if (log)
1219 {
1220 if (target_sp.get() == NULL)
1221 log->Printf ("SBValue(%p)::GetTarget () => NULL", m_opaque_sp.get());
1222 else
1223 log->Printf ("SBValue(%p)::GetTarget () => %p", m_opaque_sp.get(), target_sp.get());
1224 }
1225 return sb_target;
1226 }
1227
1228 lldb::SBProcess
GetProcess()1229 SBValue::GetProcess()
1230 {
1231 SBProcess sb_process;
1232 ProcessSP process_sp;
1233 if (m_opaque_sp)
1234 {
1235 process_sp = m_opaque_sp->GetProcessSP();
1236 sb_process.SetSP (process_sp);
1237 }
1238 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1239 if (log)
1240 {
1241 if (process_sp.get() == NULL)
1242 log->Printf ("SBValue(%p)::GetProcess () => NULL", m_opaque_sp.get());
1243 else
1244 log->Printf ("SBValue(%p)::GetProcess () => %p", m_opaque_sp.get(), process_sp.get());
1245 }
1246 return sb_process;
1247 }
1248
1249 lldb::SBThread
GetThread()1250 SBValue::GetThread()
1251 {
1252 SBThread sb_thread;
1253 ThreadSP thread_sp;
1254 if (m_opaque_sp)
1255 {
1256 thread_sp = m_opaque_sp->GetThreadSP();
1257 sb_thread.SetThread(thread_sp);
1258 }
1259 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1260 if (log)
1261 {
1262 if (thread_sp.get() == NULL)
1263 log->Printf ("SBValue(%p)::GetThread () => NULL", m_opaque_sp.get());
1264 else
1265 log->Printf ("SBValue(%p)::GetThread () => %p", m_opaque_sp.get(), thread_sp.get());
1266 }
1267 return sb_thread;
1268 }
1269
1270 lldb::SBFrame
GetFrame()1271 SBValue::GetFrame()
1272 {
1273 SBFrame sb_frame;
1274 StackFrameSP frame_sp;
1275 if (m_opaque_sp)
1276 {
1277 frame_sp = m_opaque_sp->GetFrameSP();
1278 sb_frame.SetFrameSP (frame_sp);
1279 }
1280 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1281 if (log)
1282 {
1283 if (frame_sp.get() == NULL)
1284 log->Printf ("SBValue(%p)::GetFrame () => NULL", m_opaque_sp.get());
1285 else
1286 log->Printf ("SBValue(%p)::GetFrame () => %p", m_opaque_sp.get(), frame_sp.get());
1287 }
1288 return sb_frame;
1289 }
1290
1291
1292 lldb::ValueObjectSP
GetSP(ValueLocker & locker) const1293 SBValue::GetSP (ValueLocker &locker) const
1294 {
1295 if (!m_opaque_sp || !m_opaque_sp->IsValid())
1296 return ValueObjectSP();
1297 return locker.GetLockedSP(*m_opaque_sp.get());
1298 }
1299
1300 lldb::ValueObjectSP
GetSP() const1301 SBValue::GetSP () const
1302 {
1303 ValueLocker locker;
1304 return GetSP(locker);
1305 }
1306
1307 void
SetSP(ValueImplSP impl_sp)1308 SBValue::SetSP (ValueImplSP impl_sp)
1309 {
1310 m_opaque_sp = impl_sp;
1311 }
1312
1313 void
SetSP(const lldb::ValueObjectSP & sp)1314 SBValue::SetSP (const lldb::ValueObjectSP &sp)
1315 {
1316 if (sp)
1317 {
1318 lldb::TargetSP target_sp(sp->GetTargetSP());
1319 if (target_sp)
1320 {
1321 lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
1322 bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue();
1323 m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
1324 }
1325 else
1326 m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,true));
1327 }
1328 else
1329 m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,false));
1330 }
1331
1332 void
SetSP(const lldb::ValueObjectSP & sp,lldb::DynamicValueType use_dynamic)1333 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic)
1334 {
1335 if (sp)
1336 {
1337 lldb::TargetSP target_sp(sp->GetTargetSP());
1338 if (target_sp)
1339 {
1340 bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue();
1341 SetSP (sp, use_dynamic, use_synthetic);
1342 }
1343 else
1344 SetSP (sp, use_dynamic, true);
1345 }
1346 else
1347 SetSP (sp, use_dynamic, false);
1348 }
1349
1350 void
SetSP(const lldb::ValueObjectSP & sp,bool use_synthetic)1351 SBValue::SetSP (const lldb::ValueObjectSP &sp, bool use_synthetic)
1352 {
1353 if (sp)
1354 {
1355 lldb::TargetSP target_sp(sp->GetTargetSP());
1356 if (target_sp)
1357 {
1358 lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
1359 SetSP (sp, use_dynamic, use_synthetic);
1360 }
1361 else
1362 SetSP (sp, eNoDynamicValues, use_synthetic);
1363 }
1364 else
1365 SetSP (sp, eNoDynamicValues, use_synthetic);
1366 }
1367
1368 void
SetSP(const lldb::ValueObjectSP & sp,lldb::DynamicValueType use_dynamic,bool use_synthetic)1369 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic)
1370 {
1371 m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic));
1372 }
1373
1374 void
SetSP(const lldb::ValueObjectSP & sp,lldb::DynamicValueType use_dynamic,bool use_synthetic,const char * name)1375 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name)
1376 {
1377 m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic, name));
1378 }
1379
1380 bool
GetExpressionPath(SBStream & description)1381 SBValue::GetExpressionPath (SBStream &description)
1382 {
1383 ValueLocker locker;
1384 lldb::ValueObjectSP value_sp(GetSP(locker));
1385 if (value_sp)
1386 {
1387 value_sp->GetExpressionPath (description.ref(), false);
1388 return true;
1389 }
1390 return false;
1391 }
1392
1393 bool
GetExpressionPath(SBStream & description,bool qualify_cxx_base_classes)1394 SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
1395 {
1396 ValueLocker locker;
1397 lldb::ValueObjectSP value_sp(GetSP(locker));
1398 if (value_sp)
1399 {
1400 value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
1401 return true;
1402 }
1403 return false;
1404 }
1405
1406 bool
GetDescription(SBStream & description)1407 SBValue::GetDescription (SBStream &description)
1408 {
1409 Stream &strm = description.ref();
1410
1411 ValueLocker locker;
1412 lldb::ValueObjectSP value_sp(GetSP(locker));
1413 if (value_sp)
1414 value_sp->Dump(strm);
1415 else
1416 strm.PutCString ("No value");
1417
1418 return true;
1419 }
1420
1421 lldb::Format
GetFormat()1422 SBValue::GetFormat ()
1423 {
1424 ValueLocker locker;
1425 lldb::ValueObjectSP value_sp(GetSP(locker));
1426 if (value_sp)
1427 return value_sp->GetFormat();
1428 return eFormatDefault;
1429 }
1430
1431 void
SetFormat(lldb::Format format)1432 SBValue::SetFormat (lldb::Format format)
1433 {
1434 ValueLocker locker;
1435 lldb::ValueObjectSP value_sp(GetSP(locker));
1436 if (value_sp)
1437 value_sp->SetFormat(format);
1438 }
1439
1440 lldb::SBValue
AddressOf()1441 SBValue::AddressOf()
1442 {
1443 SBValue sb_value;
1444 ValueLocker locker;
1445 lldb::ValueObjectSP value_sp(GetSP(locker));
1446 if (value_sp)
1447 {
1448 Error error;
1449 sb_value.SetSP(value_sp->AddressOf (error),GetPreferDynamicValue(), GetPreferSyntheticValue());
1450 }
1451 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1452 if (log)
1453 log->Printf ("SBValue(%p)::AddressOf () => SBValue(%p)", value_sp.get(), value_sp.get());
1454
1455 return sb_value;
1456 }
1457
1458 lldb::addr_t
GetLoadAddress()1459 SBValue::GetLoadAddress()
1460 {
1461 lldb::addr_t value = LLDB_INVALID_ADDRESS;
1462 ValueLocker locker;
1463 lldb::ValueObjectSP value_sp(GetSP(locker));
1464 if (value_sp)
1465 {
1466 TargetSP target_sp (value_sp->GetTargetSP());
1467 if (target_sp)
1468 {
1469 const bool scalar_is_load_address = true;
1470 AddressType addr_type;
1471 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1472 if (addr_type == eAddressTypeFile)
1473 {
1474 ModuleSP module_sp (value_sp->GetModule());
1475 if (!module_sp)
1476 value = LLDB_INVALID_ADDRESS;
1477 else
1478 {
1479 Address addr;
1480 module_sp->ResolveFileAddress(value, addr);
1481 value = addr.GetLoadAddress(target_sp.get());
1482 }
1483 }
1484 else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid)
1485 value = LLDB_INVALID_ADDRESS;
1486 }
1487 }
1488 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1489 if (log)
1490 log->Printf ("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")", value_sp.get(), value);
1491
1492 return value;
1493 }
1494
1495 lldb::SBAddress
GetAddress()1496 SBValue::GetAddress()
1497 {
1498 Address addr;
1499 ValueLocker locker;
1500 lldb::ValueObjectSP value_sp(GetSP(locker));
1501 if (value_sp)
1502 {
1503 TargetSP target_sp (value_sp->GetTargetSP());
1504 if (target_sp)
1505 {
1506 lldb::addr_t value = LLDB_INVALID_ADDRESS;
1507 const bool scalar_is_load_address = true;
1508 AddressType addr_type;
1509 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1510 if (addr_type == eAddressTypeFile)
1511 {
1512 ModuleSP module_sp (value_sp->GetModule());
1513 if (module_sp)
1514 module_sp->ResolveFileAddress(value, addr);
1515 }
1516 else if (addr_type == eAddressTypeLoad)
1517 {
1518 // no need to check the return value on this.. if it can actually do the resolve
1519 // addr will be in the form (section,offset), otherwise it will simply be returned
1520 // as (NULL, value)
1521 addr.SetLoadAddress(value, target_sp.get());
1522 }
1523 }
1524 }
1525 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1526 if (log)
1527 log->Printf ("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")", value_sp.get(),
1528 (addr.GetSection() ? addr.GetSection()->GetName().GetCString() : "NULL"),
1529 addr.GetOffset());
1530 return SBAddress(new Address(addr));
1531 }
1532
1533 lldb::SBData
GetPointeeData(uint32_t item_idx,uint32_t item_count)1534 SBValue::GetPointeeData (uint32_t item_idx,
1535 uint32_t item_count)
1536 {
1537 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1538 lldb::SBData sb_data;
1539 ValueLocker locker;
1540 lldb::ValueObjectSP value_sp(GetSP(locker));
1541 if (value_sp)
1542 {
1543 TargetSP target_sp (value_sp->GetTargetSP());
1544 if (target_sp)
1545 {
1546 DataExtractorSP data_sp(new DataExtractor());
1547 value_sp->GetPointeeData(*data_sp, item_idx, item_count);
1548 if (data_sp->GetByteSize() > 0)
1549 *sb_data = data_sp;
1550 }
1551 }
1552 if (log)
1553 log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
1554 value_sp.get(),
1555 item_idx,
1556 item_count,
1557 sb_data.get());
1558
1559 return sb_data;
1560 }
1561
1562 lldb::SBData
GetData()1563 SBValue::GetData ()
1564 {
1565 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1566 lldb::SBData sb_data;
1567 ValueLocker locker;
1568 lldb::ValueObjectSP value_sp(GetSP(locker));
1569 if (value_sp)
1570 {
1571 DataExtractorSP data_sp(new DataExtractor());
1572 value_sp->GetData(*data_sp);
1573 if (data_sp->GetByteSize() > 0)
1574 *sb_data = data_sp;
1575 }
1576 if (log)
1577 log->Printf ("SBValue(%p)::GetData () => SBData(%p)",
1578 value_sp.get(),
1579 sb_data.get());
1580
1581 return sb_data;
1582 }
1583
1584 bool
SetData(lldb::SBData & data,SBError & error)1585 SBValue::SetData (lldb::SBData &data, SBError &error)
1586 {
1587 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1588 ValueLocker locker;
1589 lldb::ValueObjectSP value_sp(GetSP(locker));
1590 bool ret = true;
1591
1592 if (value_sp)
1593 {
1594 DataExtractor *data_extractor = data.get();
1595
1596 if (!data_extractor)
1597 {
1598 if (log)
1599 log->Printf ("SBValue(%p)::SetData() => error: no data to set", value_sp.get());
1600
1601 error.SetErrorString("No data to set");
1602 ret = false;
1603 }
1604 else
1605 {
1606 Error set_error;
1607
1608 value_sp->SetData(*data_extractor, set_error);
1609
1610 if (!set_error.Success())
1611 {
1612 error.SetErrorStringWithFormat("Couldn't set data: %s", set_error.AsCString());
1613 ret = false;
1614 }
1615 }
1616 }
1617 else
1618 {
1619 error.SetErrorStringWithFormat ("Couldn't set data: could not get SBValue: %s", locker.GetError().AsCString());
1620 ret = false;
1621 }
1622
1623 if (log)
1624 log->Printf ("SBValue(%p)::SetData (%p) => %s",
1625 value_sp.get(),
1626 data.get(),
1627 ret ? "true" : "false");
1628 return ret;
1629 }
1630
1631 lldb::SBDeclaration
GetDeclaration()1632 SBValue::GetDeclaration ()
1633 {
1634 ValueLocker locker;
1635 lldb::ValueObjectSP value_sp(GetSP(locker));
1636 SBDeclaration decl_sb;
1637 if (value_sp)
1638 {
1639 Declaration decl;
1640 if (value_sp->GetDeclaration(decl))
1641 decl_sb.SetDeclaration(decl);
1642 }
1643 return decl_sb;
1644 }
1645
1646 lldb::SBWatchpoint
Watch(bool resolve_location,bool read,bool write,SBError & error)1647 SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error)
1648 {
1649 SBWatchpoint sb_watchpoint;
1650
1651 // If the SBValue is not valid, there's no point in even trying to watch it.
1652 ValueLocker locker;
1653 lldb::ValueObjectSP value_sp(GetSP(locker));
1654 TargetSP target_sp (GetTarget().GetSP());
1655 if (value_sp && target_sp)
1656 {
1657 // Read and Write cannot both be false.
1658 if (!read && !write)
1659 return sb_watchpoint;
1660
1661 // If the value is not in scope, don't try and watch and invalid value
1662 if (!IsInScope())
1663 return sb_watchpoint;
1664
1665 addr_t addr = GetLoadAddress();
1666 if (addr == LLDB_INVALID_ADDRESS)
1667 return sb_watchpoint;
1668 size_t byte_size = GetByteSize();
1669 if (byte_size == 0)
1670 return sb_watchpoint;
1671
1672 uint32_t watch_type = 0;
1673 if (read)
1674 watch_type |= LLDB_WATCH_TYPE_READ;
1675 if (write)
1676 watch_type |= LLDB_WATCH_TYPE_WRITE;
1677
1678 Error rc;
1679 ClangASTType type (value_sp->GetClangType());
1680 WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
1681 error.SetError(rc);
1682
1683 if (watchpoint_sp)
1684 {
1685 sb_watchpoint.SetSP (watchpoint_sp);
1686 Declaration decl;
1687 if (value_sp->GetDeclaration (decl))
1688 {
1689 if (decl.GetFile())
1690 {
1691 StreamString ss;
1692 // True to show fullpath for declaration file.
1693 decl.DumpStopContext(&ss, true);
1694 watchpoint_sp->SetDeclInfo(ss.GetString());
1695 }
1696 }
1697 }
1698 }
1699 else if (target_sp)
1700 {
1701 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1702 if (log)
1703 log->Printf ("SBValue(%p)::Watch() => error getting SBValue: %s", value_sp.get(), locker.GetError().AsCString());
1704
1705 error.SetErrorStringWithFormat("could not get SBValue: %s", locker.GetError().AsCString());
1706 }
1707 else
1708 {
1709 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1710 if (log)
1711 log->Printf ("SBValue(%p)::Watch() => error getting SBValue: no target", value_sp.get());
1712 error.SetErrorString("could not set watchpoint, a target is required");
1713 }
1714
1715 return sb_watchpoint;
1716 }
1717
1718 // FIXME: Remove this method impl (as well as the decl in .h) once it is no longer needed.
1719 // Backward compatibility fix in the interim.
1720 lldb::SBWatchpoint
Watch(bool resolve_location,bool read,bool write)1721 SBValue::Watch (bool resolve_location, bool read, bool write)
1722 {
1723 SBError error;
1724 return Watch(resolve_location, read, write, error);
1725 }
1726
1727 lldb::SBWatchpoint
WatchPointee(bool resolve_location,bool read,bool write,SBError & error)1728 SBValue::WatchPointee (bool resolve_location, bool read, bool write, SBError &error)
1729 {
1730 SBWatchpoint sb_watchpoint;
1731 if (IsInScope() && GetType().IsPointerType())
1732 sb_watchpoint = Dereference().Watch (resolve_location, read, write, error);
1733 return sb_watchpoint;
1734 }
1735