1 //===-- ValueObject.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/Core/ValueObject.h"
13
14 // C Includes
15 #include <stdlib.h>
16
17 // C++ Includes
18 // Other libraries and framework includes
19 #include "llvm/Support/raw_ostream.h"
20 #include "clang/AST/Type.h"
21
22 // Project includes
23 #include "lldb/Core/DataBufferHeap.h"
24 #include "lldb/Core/Debugger.h"
25 #include "lldb/Core/Log.h"
26 #include "lldb/Core/Module.h"
27 #include "lldb/Core/StreamString.h"
28 #include "lldb/Core/ValueObjectCast.h"
29 #include "lldb/Core/ValueObjectChild.h"
30 #include "lldb/Core/ValueObjectConstResult.h"
31 #include "lldb/Core/ValueObjectDynamicValue.h"
32 #include "lldb/Core/ValueObjectList.h"
33 #include "lldb/Core/ValueObjectMemory.h"
34 #include "lldb/Core/ValueObjectSyntheticFilter.h"
35
36 #include "lldb/DataFormatters/DataVisualization.h"
37 #include "lldb/DataFormatters/ValueObjectPrinter.h"
38
39 #include "lldb/Host/Endian.h"
40
41 #include "lldb/Interpreter/CommandInterpreter.h"
42 #include "lldb/Interpreter/ScriptInterpreterPython.h"
43
44 #include "lldb/Symbol/ClangASTType.h"
45 #include "lldb/Symbol/ClangASTContext.h"
46 #include "lldb/Symbol/Type.h"
47
48 #include "lldb/Target/ExecutionContext.h"
49 #include "lldb/Target/LanguageRuntime.h"
50 #include "lldb/Target/ObjCLanguageRuntime.h"
51 #include "lldb/Target/Process.h"
52 #include "lldb/Target/RegisterContext.h"
53 #include "lldb/Target/SectionLoadList.h"
54 #include "lldb/Target/Target.h"
55 #include "lldb/Target/Thread.h"
56
57 using namespace lldb;
58 using namespace lldb_private;
59 using namespace lldb_utility;
60
61 static user_id_t g_value_obj_uid = 0;
62
63 //----------------------------------------------------------------------
64 // ValueObject constructor
65 //----------------------------------------------------------------------
ValueObject(ValueObject & parent)66 ValueObject::ValueObject (ValueObject &parent) :
67 UserID (++g_value_obj_uid), // Unique identifier for every value object
68 m_parent (&parent),
69 m_root (NULL),
70 m_update_point (parent.GetUpdatePoint ()),
71 m_name (),
72 m_data (),
73 m_value (),
74 m_error (),
75 m_value_str (),
76 m_old_value_str (),
77 m_location_str (),
78 m_summary_str (),
79 m_object_desc_str (),
80 m_manager(parent.GetManager()),
81 m_children (),
82 m_synthetic_children (),
83 m_dynamic_value (NULL),
84 m_synthetic_value(NULL),
85 m_deref_valobj(NULL),
86 m_format (eFormatDefault),
87 m_last_format (eFormatDefault),
88 m_last_format_mgr_revision(0),
89 m_type_summary_sp(),
90 m_type_format_sp(),
91 m_synthetic_children_sp(),
92 m_user_id_of_forced_summary(),
93 m_address_type_of_ptr_or_ref_children(eAddressTypeInvalid),
94 m_value_is_valid (false),
95 m_value_did_change (false),
96 m_children_count_valid (false),
97 m_old_value_valid (false),
98 m_is_deref_of_parent (false),
99 m_is_array_item_for_pointer(false),
100 m_is_bitfield_for_scalar(false),
101 m_is_child_at_offset(false),
102 m_is_getting_summary(false),
103 m_did_calculate_complete_objc_class_type(false)
104 {
105 m_manager->ManageObject(this);
106 }
107
108 //----------------------------------------------------------------------
109 // ValueObject constructor
110 //----------------------------------------------------------------------
ValueObject(ExecutionContextScope * exe_scope,AddressType child_ptr_or_ref_addr_type)111 ValueObject::ValueObject (ExecutionContextScope *exe_scope,
112 AddressType child_ptr_or_ref_addr_type) :
113 UserID (++g_value_obj_uid), // Unique identifier for every value object
114 m_parent (NULL),
115 m_root (NULL),
116 m_update_point (exe_scope),
117 m_name (),
118 m_data (),
119 m_value (),
120 m_error (),
121 m_value_str (),
122 m_old_value_str (),
123 m_location_str (),
124 m_summary_str (),
125 m_object_desc_str (),
126 m_manager(),
127 m_children (),
128 m_synthetic_children (),
129 m_dynamic_value (NULL),
130 m_synthetic_value(NULL),
131 m_deref_valobj(NULL),
132 m_format (eFormatDefault),
133 m_last_format (eFormatDefault),
134 m_last_format_mgr_revision(0),
135 m_type_summary_sp(),
136 m_type_format_sp(),
137 m_synthetic_children_sp(),
138 m_user_id_of_forced_summary(),
139 m_address_type_of_ptr_or_ref_children(child_ptr_or_ref_addr_type),
140 m_value_is_valid (false),
141 m_value_did_change (false),
142 m_children_count_valid (false),
143 m_old_value_valid (false),
144 m_is_deref_of_parent (false),
145 m_is_array_item_for_pointer(false),
146 m_is_bitfield_for_scalar(false),
147 m_is_child_at_offset(false),
148 m_is_getting_summary(false),
149 m_did_calculate_complete_objc_class_type(false)
150 {
151 m_manager = new ValueObjectManager();
152 m_manager->ManageObject (this);
153 }
154
155 //----------------------------------------------------------------------
156 // Destructor
157 //----------------------------------------------------------------------
~ValueObject()158 ValueObject::~ValueObject ()
159 {
160 }
161
162 bool
UpdateValueIfNeeded(bool update_format)163 ValueObject::UpdateValueIfNeeded (bool update_format)
164 {
165
166 bool did_change_formats = false;
167
168 if (update_format)
169 did_change_formats = UpdateFormatsIfNeeded();
170
171 // If this is a constant value, then our success is predicated on whether
172 // we have an error or not
173 if (GetIsConstant())
174 {
175 // if you are constant, things might still have changed behind your back
176 // (e.g. you are a frozen object and things have changed deeper than you cared to freeze-dry yourself)
177 // in this case, your value has not changed, but "computed" entries might have, so you might now have
178 // a different summary, or a different object description. clear these so we will recompute them
179 if (update_format && !did_change_formats)
180 ClearUserVisibleData(eClearUserVisibleDataItemsSummary | eClearUserVisibleDataItemsDescription);
181 return m_error.Success();
182 }
183
184 bool first_update = m_update_point.IsFirstEvaluation();
185
186 if (m_update_point.NeedsUpdating())
187 {
188 m_update_point.SetUpdated();
189
190 // Save the old value using swap to avoid a string copy which
191 // also will clear our m_value_str
192 if (m_value_str.empty())
193 {
194 m_old_value_valid = false;
195 }
196 else
197 {
198 m_old_value_valid = true;
199 m_old_value_str.swap (m_value_str);
200 ClearUserVisibleData(eClearUserVisibleDataItemsValue);
201 }
202
203 ClearUserVisibleData();
204
205 if (IsInScope())
206 {
207 const bool value_was_valid = GetValueIsValid();
208 SetValueDidChange (false);
209
210 m_error.Clear();
211
212 // Call the pure virtual function to update the value
213 bool success = UpdateValue ();
214
215 SetValueIsValid (success);
216
217 if (first_update)
218 SetValueDidChange (false);
219 else if (!m_value_did_change && success == false)
220 {
221 // The value wasn't gotten successfully, so we mark this
222 // as changed if the value used to be valid and now isn't
223 SetValueDidChange (value_was_valid);
224 }
225 }
226 else
227 {
228 m_error.SetErrorString("out of scope");
229 }
230 }
231 return m_error.Success();
232 }
233
234 bool
UpdateFormatsIfNeeded()235 ValueObject::UpdateFormatsIfNeeded()
236 {
237 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
238 if (log)
239 log->Printf("[%s %p] checking for FormatManager revisions. ValueObject rev: %d - Global rev: %d",
240 GetName().GetCString(),
241 this,
242 m_last_format_mgr_revision,
243 DataVisualization::GetCurrentRevision());
244
245 bool any_change = false;
246
247 if ( (m_last_format_mgr_revision != DataVisualization::GetCurrentRevision()))
248 {
249 SetValueFormat(DataVisualization::GetFormat (*this, eNoDynamicValues));
250 SetSummaryFormat(DataVisualization::GetSummaryFormat (*this, GetDynamicValueType()));
251 #ifndef LLDB_DISABLE_PYTHON
252 SetSyntheticChildren(DataVisualization::GetSyntheticChildren (*this, GetDynamicValueType()));
253 #endif
254
255 m_last_format_mgr_revision = DataVisualization::GetCurrentRevision();
256
257 any_change = true;
258 }
259
260 return any_change;
261
262 }
263
264 void
SetNeedsUpdate()265 ValueObject::SetNeedsUpdate ()
266 {
267 m_update_point.SetNeedsUpdate();
268 // We have to clear the value string here so ConstResult children will notice if their values are
269 // changed by hand (i.e. with SetValueAsCString).
270 ClearUserVisibleData(eClearUserVisibleDataItemsValue);
271 }
272
273 void
ClearDynamicTypeInformation()274 ValueObject::ClearDynamicTypeInformation ()
275 {
276 m_children_count_valid = false;
277 m_did_calculate_complete_objc_class_type = false;
278 m_last_format_mgr_revision = 0;
279 m_override_type = ClangASTType();
280 SetValueFormat(lldb::TypeFormatImplSP());
281 SetSummaryFormat(lldb::TypeSummaryImplSP());
282 SetSyntheticChildren(lldb::SyntheticChildrenSP());
283 }
284
285 ClangASTType
MaybeCalculateCompleteType()286 ValueObject::MaybeCalculateCompleteType ()
287 {
288 ClangASTType clang_type(GetClangTypeImpl());
289
290 if (m_did_calculate_complete_objc_class_type)
291 {
292 if (m_override_type.IsValid())
293 return m_override_type;
294 else
295 return clang_type;
296 }
297
298 ClangASTType class_type;
299 bool is_pointer_type = false;
300
301 if (clang_type.IsObjCObjectPointerType(&class_type))
302 {
303 is_pointer_type = true;
304 }
305 else if (clang_type.IsObjCObjectOrInterfaceType())
306 {
307 class_type = clang_type;
308 }
309 else
310 {
311 return clang_type;
312 }
313
314 m_did_calculate_complete_objc_class_type = true;
315
316 if (class_type)
317 {
318 ConstString class_name (class_type.GetConstTypeName());
319
320 if (class_name)
321 {
322 ProcessSP process_sp(GetUpdatePoint().GetExecutionContextRef().GetProcessSP());
323
324 if (process_sp)
325 {
326 ObjCLanguageRuntime *objc_language_runtime(process_sp->GetObjCLanguageRuntime());
327
328 if (objc_language_runtime)
329 {
330 TypeSP complete_objc_class_type_sp = objc_language_runtime->LookupInCompleteClassCache(class_name);
331
332 if (complete_objc_class_type_sp)
333 {
334 ClangASTType complete_class(complete_objc_class_type_sp->GetClangFullType());
335
336 if (complete_class.GetCompleteType())
337 {
338 if (is_pointer_type)
339 {
340 m_override_type = complete_class.GetPointerType();
341 }
342 else
343 {
344 m_override_type = complete_class;
345 }
346
347 if (m_override_type.IsValid())
348 return m_override_type;
349 }
350 }
351 }
352 }
353 }
354 }
355 return clang_type;
356 }
357
358 ClangASTType
GetClangType()359 ValueObject::GetClangType ()
360 {
361 return MaybeCalculateCompleteType();
362 }
363
364 TypeImpl
GetTypeImpl()365 ValueObject::GetTypeImpl ()
366 {
367 return TypeImpl(GetClangType());
368 }
369
370 DataExtractor &
GetDataExtractor()371 ValueObject::GetDataExtractor ()
372 {
373 UpdateValueIfNeeded(false);
374 return m_data;
375 }
376
377 const Error &
GetError()378 ValueObject::GetError()
379 {
380 UpdateValueIfNeeded(false);
381 return m_error;
382 }
383
384 const ConstString &
GetName() const385 ValueObject::GetName() const
386 {
387 return m_name;
388 }
389
390 const char *
GetLocationAsCString()391 ValueObject::GetLocationAsCString ()
392 {
393 return GetLocationAsCStringImpl(m_value,
394 m_data);
395 }
396
397 const char *
GetLocationAsCStringImpl(const Value & value,const DataExtractor & data)398 ValueObject::GetLocationAsCStringImpl (const Value& value,
399 const DataExtractor& data)
400 {
401 if (UpdateValueIfNeeded(false))
402 {
403 if (m_location_str.empty())
404 {
405 StreamString sstr;
406
407 Value::ValueType value_type = value.GetValueType();
408
409 switch (value_type)
410 {
411 case Value::eValueTypeScalar:
412 case Value::eValueTypeVector:
413 if (value.GetContextType() == Value::eContextTypeRegisterInfo)
414 {
415 RegisterInfo *reg_info = value.GetRegisterInfo();
416 if (reg_info)
417 {
418 if (reg_info->name)
419 m_location_str = reg_info->name;
420 else if (reg_info->alt_name)
421 m_location_str = reg_info->alt_name;
422 if (m_location_str.empty())
423 m_location_str = (reg_info->encoding == lldb::eEncodingVector) ? "vector" : "scalar";
424 }
425 }
426 if (m_location_str.empty())
427 m_location_str = (value_type == Value::eValueTypeVector) ? "vector" : "scalar";
428 break;
429
430 case Value::eValueTypeLoadAddress:
431 case Value::eValueTypeFileAddress:
432 case Value::eValueTypeHostAddress:
433 {
434 uint32_t addr_nibble_size = data.GetAddressByteSize() * 2;
435 sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size, value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
436 m_location_str.swap(sstr.GetString());
437 }
438 break;
439 }
440 }
441 }
442 return m_location_str.c_str();
443 }
444
445 Value &
GetValue()446 ValueObject::GetValue()
447 {
448 return m_value;
449 }
450
451 const Value &
GetValue() const452 ValueObject::GetValue() const
453 {
454 return m_value;
455 }
456
457 bool
ResolveValue(Scalar & scalar)458 ValueObject::ResolveValue (Scalar &scalar)
459 {
460 if (UpdateValueIfNeeded(false)) // make sure that you are up to date before returning anything
461 {
462 ExecutionContext exe_ctx (GetExecutionContextRef());
463 Value tmp_value(m_value);
464 scalar = tmp_value.ResolveValue(&exe_ctx);
465 if (scalar.IsValid())
466 {
467 const uint32_t bitfield_bit_size = GetBitfieldBitSize();
468 if (bitfield_bit_size)
469 return scalar.ExtractBitfield (bitfield_bit_size, GetBitfieldBitOffset());
470 return true;
471 }
472 }
473 return false;
474 }
475
476 bool
GetValueIsValid() const477 ValueObject::GetValueIsValid () const
478 {
479 return m_value_is_valid;
480 }
481
482
483 void
SetValueIsValid(bool b)484 ValueObject::SetValueIsValid (bool b)
485 {
486 m_value_is_valid = b;
487 }
488
489 bool
GetValueDidChange()490 ValueObject::GetValueDidChange ()
491 {
492 GetValueAsCString ();
493 return m_value_did_change;
494 }
495
496 void
SetValueDidChange(bool value_changed)497 ValueObject::SetValueDidChange (bool value_changed)
498 {
499 m_value_did_change = value_changed;
500 }
501
502 ValueObjectSP
GetChildAtIndex(size_t idx,bool can_create)503 ValueObject::GetChildAtIndex (size_t idx, bool can_create)
504 {
505 ValueObjectSP child_sp;
506 // We may need to update our value if we are dynamic
507 if (IsPossibleDynamicType ())
508 UpdateValueIfNeeded(false);
509 if (idx < GetNumChildren())
510 {
511 // Check if we have already made the child value object?
512 if (can_create && !m_children.HasChildAtIndex(idx))
513 {
514 // No we haven't created the child at this index, so lets have our
515 // subclass do it and cache the result for quick future access.
516 m_children.SetChildAtIndex(idx,CreateChildAtIndex (idx, false, 0));
517 }
518
519 ValueObject* child = m_children.GetChildAtIndex(idx);
520 if (child != NULL)
521 return child->GetSP();
522 }
523 return child_sp;
524 }
525
526 ValueObjectSP
GetChildAtIndexPath(const std::initializer_list<size_t> & idxs,size_t * index_of_error)527 ValueObject::GetChildAtIndexPath (const std::initializer_list<size_t>& idxs,
528 size_t* index_of_error)
529 {
530 if (idxs.size() == 0)
531 return GetSP();
532 ValueObjectSP root(GetSP());
533 for (size_t idx : idxs)
534 {
535 root = root->GetChildAtIndex(idx, true);
536 if (!root)
537 {
538 if (index_of_error)
539 *index_of_error = idx;
540 return root;
541 }
542 }
543 return root;
544 }
545
546 ValueObjectSP
GetChildAtIndexPath(const std::initializer_list<std::pair<size_t,bool>> & idxs,size_t * index_of_error)547 ValueObject::GetChildAtIndexPath (const std::initializer_list< std::pair<size_t, bool> >& idxs,
548 size_t* index_of_error)
549 {
550 if (idxs.size() == 0)
551 return GetSP();
552 ValueObjectSP root(GetSP());
553 for (std::pair<size_t, bool> idx : idxs)
554 {
555 root = root->GetChildAtIndex(idx.first, idx.second);
556 if (!root)
557 {
558 if (index_of_error)
559 *index_of_error = idx.first;
560 return root;
561 }
562 }
563 return root;
564 }
565
566 lldb::ValueObjectSP
GetChildAtIndexPath(const std::vector<size_t> & idxs,size_t * index_of_error)567 ValueObject::GetChildAtIndexPath (const std::vector<size_t> &idxs,
568 size_t* index_of_error)
569 {
570 if (idxs.size() == 0)
571 return GetSP();
572 ValueObjectSP root(GetSP());
573 for (size_t idx : idxs)
574 {
575 root = root->GetChildAtIndex(idx, true);
576 if (!root)
577 {
578 if (index_of_error)
579 *index_of_error = idx;
580 return root;
581 }
582 }
583 return root;
584 }
585
586 lldb::ValueObjectSP
GetChildAtIndexPath(const std::vector<std::pair<size_t,bool>> & idxs,size_t * index_of_error)587 ValueObject::GetChildAtIndexPath (const std::vector< std::pair<size_t, bool> > &idxs,
588 size_t* index_of_error)
589 {
590 if (idxs.size() == 0)
591 return GetSP();
592 ValueObjectSP root(GetSP());
593 for (std::pair<size_t, bool> idx : idxs)
594 {
595 root = root->GetChildAtIndex(idx.first, idx.second);
596 if (!root)
597 {
598 if (index_of_error)
599 *index_of_error = idx.first;
600 return root;
601 }
602 }
603 return root;
604 }
605
606 lldb::ValueObjectSP
GetChildAtNamePath(const std::initializer_list<ConstString> & names,ConstString * name_of_error)607 ValueObject::GetChildAtNamePath (const std::initializer_list<ConstString> &names,
608 ConstString* name_of_error)
609 {
610 if (names.size() == 0)
611 return GetSP();
612 ValueObjectSP root(GetSP());
613 for (ConstString name : names)
614 {
615 root = root->GetChildMemberWithName(name, true);
616 if (!root)
617 {
618 if (name_of_error)
619 *name_of_error = name;
620 return root;
621 }
622 }
623 return root;
624 }
625
626 lldb::ValueObjectSP
GetChildAtNamePath(const std::vector<ConstString> & names,ConstString * name_of_error)627 ValueObject::GetChildAtNamePath (const std::vector<ConstString> &names,
628 ConstString* name_of_error)
629 {
630 if (names.size() == 0)
631 return GetSP();
632 ValueObjectSP root(GetSP());
633 for (ConstString name : names)
634 {
635 root = root->GetChildMemberWithName(name, true);
636 if (!root)
637 {
638 if (name_of_error)
639 *name_of_error = name;
640 return root;
641 }
642 }
643 return root;
644 }
645
646 lldb::ValueObjectSP
GetChildAtNamePath(const std::initializer_list<std::pair<ConstString,bool>> & names,ConstString * name_of_error)647 ValueObject::GetChildAtNamePath (const std::initializer_list< std::pair<ConstString, bool> > &names,
648 ConstString* name_of_error)
649 {
650 if (names.size() == 0)
651 return GetSP();
652 ValueObjectSP root(GetSP());
653 for (std::pair<ConstString, bool> name : names)
654 {
655 root = root->GetChildMemberWithName(name.first, name.second);
656 if (!root)
657 {
658 if (name_of_error)
659 *name_of_error = name.first;
660 return root;
661 }
662 }
663 return root;
664 }
665
666 lldb::ValueObjectSP
GetChildAtNamePath(const std::vector<std::pair<ConstString,bool>> & names,ConstString * name_of_error)667 ValueObject::GetChildAtNamePath (const std::vector< std::pair<ConstString, bool> > &names,
668 ConstString* name_of_error)
669 {
670 if (names.size() == 0)
671 return GetSP();
672 ValueObjectSP root(GetSP());
673 for (std::pair<ConstString, bool> name : names)
674 {
675 root = root->GetChildMemberWithName(name.first, name.second);
676 if (!root)
677 {
678 if (name_of_error)
679 *name_of_error = name.first;
680 return root;
681 }
682 }
683 return root;
684 }
685
686 size_t
GetIndexOfChildWithName(const ConstString & name)687 ValueObject::GetIndexOfChildWithName (const ConstString &name)
688 {
689 bool omit_empty_base_classes = true;
690 return GetClangType().GetIndexOfChildWithName (name.GetCString(), omit_empty_base_classes);
691 }
692
693 ValueObjectSP
GetChildMemberWithName(const ConstString & name,bool can_create)694 ValueObject::GetChildMemberWithName (const ConstString &name, bool can_create)
695 {
696 // when getting a child by name, it could be buried inside some base
697 // classes (which really aren't part of the expression path), so we
698 // need a vector of indexes that can get us down to the correct child
699 ValueObjectSP child_sp;
700
701 // We may need to update our value if we are dynamic
702 if (IsPossibleDynamicType ())
703 UpdateValueIfNeeded(false);
704
705 std::vector<uint32_t> child_indexes;
706 bool omit_empty_base_classes = true;
707 const size_t num_child_indexes = GetClangType().GetIndexOfChildMemberWithName (name.GetCString(),
708 omit_empty_base_classes,
709 child_indexes);
710 if (num_child_indexes > 0)
711 {
712 std::vector<uint32_t>::const_iterator pos = child_indexes.begin ();
713 std::vector<uint32_t>::const_iterator end = child_indexes.end ();
714
715 child_sp = GetChildAtIndex(*pos, can_create);
716 for (++pos; pos != end; ++pos)
717 {
718 if (child_sp)
719 {
720 ValueObjectSP new_child_sp(child_sp->GetChildAtIndex (*pos, can_create));
721 child_sp = new_child_sp;
722 }
723 else
724 {
725 child_sp.reset();
726 }
727
728 }
729 }
730 return child_sp;
731 }
732
733
734 size_t
GetNumChildren()735 ValueObject::GetNumChildren ()
736 {
737 UpdateValueIfNeeded();
738 if (!m_children_count_valid)
739 {
740 SetNumChildren (CalculateNumChildren());
741 }
742 return m_children.GetChildrenCount();
743 }
744
745 bool
MightHaveChildren()746 ValueObject::MightHaveChildren()
747 {
748 bool has_children = false;
749 const uint32_t type_info = GetTypeInfo();
750 if (type_info)
751 {
752 if (type_info & (ClangASTType::eTypeHasChildren |
753 ClangASTType::eTypeIsPointer |
754 ClangASTType::eTypeIsReference))
755 has_children = true;
756 }
757 else
758 {
759 has_children = GetNumChildren () > 0;
760 }
761 return has_children;
762 }
763
764 // Should only be called by ValueObject::GetNumChildren()
765 void
SetNumChildren(size_t num_children)766 ValueObject::SetNumChildren (size_t num_children)
767 {
768 m_children_count_valid = true;
769 m_children.SetChildrenCount(num_children);
770 }
771
772 void
SetName(const ConstString & name)773 ValueObject::SetName (const ConstString &name)
774 {
775 m_name = name;
776 }
777
778 ValueObject *
CreateChildAtIndex(size_t idx,bool synthetic_array_member,int32_t synthetic_index)779 ValueObject::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
780 {
781 ValueObject *valobj = NULL;
782
783 bool omit_empty_base_classes = true;
784 bool ignore_array_bounds = synthetic_array_member;
785 std::string child_name_str;
786 uint32_t child_byte_size = 0;
787 int32_t child_byte_offset = 0;
788 uint32_t child_bitfield_bit_size = 0;
789 uint32_t child_bitfield_bit_offset = 0;
790 bool child_is_base_class = false;
791 bool child_is_deref_of_parent = false;
792
793 const bool transparent_pointers = synthetic_array_member == false;
794 ClangASTType child_clang_type;
795
796 ExecutionContext exe_ctx (GetExecutionContextRef());
797
798 child_clang_type = GetClangType().GetChildClangTypeAtIndex (&exe_ctx,
799 GetName().GetCString(),
800 idx,
801 transparent_pointers,
802 omit_empty_base_classes,
803 ignore_array_bounds,
804 child_name_str,
805 child_byte_size,
806 child_byte_offset,
807 child_bitfield_bit_size,
808 child_bitfield_bit_offset,
809 child_is_base_class,
810 child_is_deref_of_parent);
811 if (child_clang_type)
812 {
813 if (synthetic_index)
814 child_byte_offset += child_byte_size * synthetic_index;
815
816 ConstString child_name;
817 if (!child_name_str.empty())
818 child_name.SetCString (child_name_str.c_str());
819
820 valobj = new ValueObjectChild (*this,
821 child_clang_type,
822 child_name,
823 child_byte_size,
824 child_byte_offset,
825 child_bitfield_bit_size,
826 child_bitfield_bit_offset,
827 child_is_base_class,
828 child_is_deref_of_parent,
829 eAddressTypeInvalid);
830 //if (valobj)
831 // valobj->SetAddressTypeOfChildren(eAddressTypeInvalid);
832 }
833
834 return valobj;
835 }
836
837 bool
GetSummaryAsCString(TypeSummaryImpl * summary_ptr,std::string & destination)838 ValueObject::GetSummaryAsCString (TypeSummaryImpl* summary_ptr,
839 std::string& destination)
840 {
841 destination.clear();
842
843 // ideally we would like to bail out if passing NULL, but if we do so
844 // we end up not providing the summary for function pointers anymore
845 if (/*summary_ptr == NULL ||*/ m_is_getting_summary)
846 return false;
847
848 m_is_getting_summary = true;
849
850 // this is a hot path in code and we prefer to avoid setting this string all too often also clearing out other
851 // information that we might care to see in a crash log. might be useful in very specific situations though.
852 /*Host::SetCrashDescriptionWithFormat("Trying to fetch a summary for %s %s. Summary provider's description is %s",
853 GetTypeName().GetCString(),
854 GetName().GetCString(),
855 summary_ptr->GetDescription().c_str());*/
856
857 if (UpdateValueIfNeeded (false))
858 {
859 if (summary_ptr)
860 {
861 if (HasSyntheticValue())
862 m_synthetic_value->UpdateValueIfNeeded(); // the summary might depend on the synthetic children being up-to-date (e.g. ${svar%#})
863 summary_ptr->FormatObject(this, destination);
864 }
865 else
866 {
867 ClangASTType clang_type = GetClangType();
868
869 // Do some default printout for function pointers
870 if (clang_type)
871 {
872 if (clang_type.IsFunctionPointerType ())
873 {
874 StreamString sstr;
875 AddressType func_ptr_address_type = eAddressTypeInvalid;
876 addr_t func_ptr_address = GetPointerValue (&func_ptr_address_type);
877 if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS)
878 {
879 switch (func_ptr_address_type)
880 {
881 case eAddressTypeInvalid:
882 case eAddressTypeFile:
883 break;
884
885 case eAddressTypeLoad:
886 {
887 ExecutionContext exe_ctx (GetExecutionContextRef());
888
889 Address so_addr;
890 Target *target = exe_ctx.GetTargetPtr();
891 if (target && target->GetSectionLoadList().IsEmpty() == false)
892 {
893 if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr))
894 {
895 so_addr.Dump (&sstr,
896 exe_ctx.GetBestExecutionContextScope(),
897 Address::DumpStyleResolvedDescription,
898 Address::DumpStyleSectionNameOffset);
899 }
900 }
901 }
902 break;
903
904 case eAddressTypeHost:
905 break;
906 }
907 }
908 if (sstr.GetSize() > 0)
909 {
910 destination.assign (1, '(');
911 destination.append (sstr.GetData(), sstr.GetSize());
912 destination.append (1, ')');
913 }
914 }
915 }
916 }
917 }
918 m_is_getting_summary = false;
919 return !destination.empty();
920 }
921
922 const char *
GetSummaryAsCString()923 ValueObject::GetSummaryAsCString ()
924 {
925 if (UpdateValueIfNeeded(true) && m_summary_str.empty())
926 {
927 GetSummaryAsCString(GetSummaryFormat().get(),
928 m_summary_str);
929 }
930 if (m_summary_str.empty())
931 return NULL;
932 return m_summary_str.c_str();
933 }
934
935 bool
IsCStringContainer(bool check_pointer)936 ValueObject::IsCStringContainer(bool check_pointer)
937 {
938 ClangASTType pointee_or_element_clang_type;
939 const Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type));
940 bool is_char_arr_ptr (type_flags.AnySet (ClangASTType::eTypeIsArray | ClangASTType::eTypeIsPointer) &&
941 pointee_or_element_clang_type.IsCharType ());
942 if (!is_char_arr_ptr)
943 return false;
944 if (!check_pointer)
945 return true;
946 if (type_flags.Test(ClangASTType::eTypeIsArray))
947 return true;
948 addr_t cstr_address = LLDB_INVALID_ADDRESS;
949 AddressType cstr_address_type = eAddressTypeInvalid;
950 cstr_address = GetAddressOf (true, &cstr_address_type);
951 return (cstr_address != LLDB_INVALID_ADDRESS);
952 }
953
954 size_t
GetPointeeData(DataExtractor & data,uint32_t item_idx,uint32_t item_count)955 ValueObject::GetPointeeData (DataExtractor& data,
956 uint32_t item_idx,
957 uint32_t item_count)
958 {
959 ClangASTType pointee_or_element_clang_type;
960 const uint32_t type_info = GetTypeInfo (&pointee_or_element_clang_type);
961 const bool is_pointer_type = type_info & ClangASTType::eTypeIsPointer;
962 const bool is_array_type = type_info & ClangASTType::eTypeIsArray;
963 if (!(is_pointer_type || is_array_type))
964 return 0;
965
966 if (item_count == 0)
967 return 0;
968
969 const uint64_t item_type_size = pointee_or_element_clang_type.GetByteSize();
970 const uint64_t bytes = item_count * item_type_size;
971 const uint64_t offset = item_idx * item_type_size;
972
973 if (item_idx == 0 && item_count == 1) // simply a deref
974 {
975 if (is_pointer_type)
976 {
977 Error error;
978 ValueObjectSP pointee_sp = Dereference(error);
979 if (error.Fail() || pointee_sp.get() == NULL)
980 return 0;
981 return pointee_sp->GetData(data);
982 }
983 else
984 {
985 ValueObjectSP child_sp = GetChildAtIndex(0, true);
986 if (child_sp.get() == NULL)
987 return 0;
988 return child_sp->GetData(data);
989 }
990 return true;
991 }
992 else /* (items > 1) */
993 {
994 Error error;
995 lldb_private::DataBufferHeap* heap_buf_ptr = NULL;
996 lldb::DataBufferSP data_sp(heap_buf_ptr = new lldb_private::DataBufferHeap());
997
998 AddressType addr_type;
999 lldb::addr_t addr = is_pointer_type ? GetPointerValue(&addr_type) : GetAddressOf(true, &addr_type);
1000
1001 switch (addr_type)
1002 {
1003 case eAddressTypeFile:
1004 {
1005 ModuleSP module_sp (GetModule());
1006 if (module_sp)
1007 {
1008 addr = addr + offset;
1009 Address so_addr;
1010 module_sp->ResolveFileAddress(addr, so_addr);
1011 ExecutionContext exe_ctx (GetExecutionContextRef());
1012 Target* target = exe_ctx.GetTargetPtr();
1013 if (target)
1014 {
1015 heap_buf_ptr->SetByteSize(bytes);
1016 size_t bytes_read = target->ReadMemory(so_addr, false, heap_buf_ptr->GetBytes(), bytes, error);
1017 if (error.Success())
1018 {
1019 data.SetData(data_sp);
1020 return bytes_read;
1021 }
1022 }
1023 }
1024 }
1025 break;
1026 case eAddressTypeLoad:
1027 {
1028 ExecutionContext exe_ctx (GetExecutionContextRef());
1029 Process *process = exe_ctx.GetProcessPtr();
1030 if (process)
1031 {
1032 heap_buf_ptr->SetByteSize(bytes);
1033 size_t bytes_read = process->ReadMemory(addr + offset, heap_buf_ptr->GetBytes(), bytes, error);
1034 if (error.Success() || bytes_read > 0)
1035 {
1036 data.SetData(data_sp);
1037 return bytes_read;
1038 }
1039 }
1040 }
1041 break;
1042 case eAddressTypeHost:
1043 {
1044 const uint64_t max_bytes = GetClangType().GetByteSize();
1045 if (max_bytes > offset)
1046 {
1047 size_t bytes_read = std::min<uint64_t>(max_bytes - offset, bytes);
1048 heap_buf_ptr->CopyData((uint8_t*)(addr + offset), bytes_read);
1049 data.SetData(data_sp);
1050 return bytes_read;
1051 }
1052 }
1053 break;
1054 case eAddressTypeInvalid:
1055 break;
1056 }
1057 }
1058 return 0;
1059 }
1060
1061 uint64_t
GetData(DataExtractor & data)1062 ValueObject::GetData (DataExtractor& data)
1063 {
1064 UpdateValueIfNeeded(false);
1065 ExecutionContext exe_ctx (GetExecutionContextRef());
1066 Error error = m_value.GetValueAsData(&exe_ctx, data, 0, GetModule().get());
1067 if (error.Fail())
1068 {
1069 if (m_data.GetByteSize())
1070 {
1071 data = m_data;
1072 return data.GetByteSize();
1073 }
1074 else
1075 {
1076 return 0;
1077 }
1078 }
1079 data.SetAddressByteSize(m_data.GetAddressByteSize());
1080 data.SetByteOrder(m_data.GetByteOrder());
1081 return data.GetByteSize();
1082 }
1083
1084 bool
SetData(DataExtractor & data,Error & error)1085 ValueObject::SetData (DataExtractor &data, Error &error)
1086 {
1087 error.Clear();
1088 // Make sure our value is up to date first so that our location and location
1089 // type is valid.
1090 if (!UpdateValueIfNeeded(false))
1091 {
1092 error.SetErrorString("unable to read value");
1093 return false;
1094 }
1095
1096 uint64_t count = 0;
1097 const Encoding encoding = GetClangType().GetEncoding(count);
1098
1099 const size_t byte_size = GetByteSize();
1100
1101 Value::ValueType value_type = m_value.GetValueType();
1102
1103 switch (value_type)
1104 {
1105 case Value::eValueTypeScalar:
1106 {
1107 Error set_error = m_value.GetScalar().SetValueFromData(data, encoding, byte_size);
1108
1109 if (!set_error.Success())
1110 {
1111 error.SetErrorStringWithFormat("unable to set scalar value: %s", set_error.AsCString());
1112 return false;
1113 }
1114 }
1115 break;
1116 case Value::eValueTypeLoadAddress:
1117 {
1118 // If it is a load address, then the scalar value is the storage location
1119 // of the data, and we have to shove this value down to that load location.
1120 ExecutionContext exe_ctx (GetExecutionContextRef());
1121 Process *process = exe_ctx.GetProcessPtr();
1122 if (process)
1123 {
1124 addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1125 size_t bytes_written = process->WriteMemory(target_addr,
1126 data.GetDataStart(),
1127 byte_size,
1128 error);
1129 if (!error.Success())
1130 return false;
1131 if (bytes_written != byte_size)
1132 {
1133 error.SetErrorString("unable to write value to memory");
1134 return false;
1135 }
1136 }
1137 }
1138 break;
1139 case Value::eValueTypeHostAddress:
1140 {
1141 // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data.
1142 DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0));
1143 m_data.SetData(buffer_sp, 0);
1144 data.CopyByteOrderedData (0,
1145 byte_size,
1146 const_cast<uint8_t *>(m_data.GetDataStart()),
1147 byte_size,
1148 m_data.GetByteOrder());
1149 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1150 }
1151 break;
1152 case Value::eValueTypeFileAddress:
1153 case Value::eValueTypeVector:
1154 break;
1155 }
1156
1157 // If we have reached this point, then we have successfully changed the value.
1158 SetNeedsUpdate();
1159 return true;
1160 }
1161
1162 // will compute strlen(str), but without consuming more than
1163 // maxlen bytes out of str (this serves the purpose of reading
1164 // chunks of a string without having to worry about
1165 // missing NULL terminators in the chunk)
1166 // of course, if strlen(str) > maxlen, the function will return
1167 // maxlen_value (which should be != maxlen, because that allows you
1168 // to know whether strlen(str) == maxlen or strlen(str) > maxlen)
1169 static uint32_t
strlen_or_inf(const char * str,uint32_t maxlen,uint32_t maxlen_value)1170 strlen_or_inf (const char* str,
1171 uint32_t maxlen,
1172 uint32_t maxlen_value)
1173 {
1174 uint32_t len = 0;
1175 if (str)
1176 {
1177 while(*str)
1178 {
1179 len++;str++;
1180 if (len >= maxlen)
1181 return maxlen_value;
1182 }
1183 }
1184 return len;
1185 }
1186
1187 size_t
ReadPointedString(Stream & s,Error & error,uint32_t max_length,bool honor_array,Format item_format)1188 ValueObject::ReadPointedString (Stream& s,
1189 Error& error,
1190 uint32_t max_length,
1191 bool honor_array,
1192 Format item_format)
1193 {
1194 ExecutionContext exe_ctx (GetExecutionContextRef());
1195 Target* target = exe_ctx.GetTargetPtr();
1196
1197 if (!target)
1198 {
1199 s << "<no target to read from>";
1200 error.SetErrorString("no target to read from");
1201 return 0;
1202 }
1203
1204 if (max_length == 0)
1205 max_length = target->GetMaximumSizeOfStringSummary();
1206
1207 size_t bytes_read = 0;
1208 size_t total_bytes_read = 0;
1209
1210 ClangASTType clang_type = GetClangType();
1211 ClangASTType elem_or_pointee_clang_type;
1212 const Flags type_flags (GetTypeInfo (&elem_or_pointee_clang_type));
1213 if (type_flags.AnySet (ClangASTType::eTypeIsArray | ClangASTType::eTypeIsPointer) &&
1214 elem_or_pointee_clang_type.IsCharType ())
1215 {
1216 addr_t cstr_address = LLDB_INVALID_ADDRESS;
1217 AddressType cstr_address_type = eAddressTypeInvalid;
1218
1219 size_t cstr_len = 0;
1220 bool capped_data = false;
1221 if (type_flags.Test (ClangASTType::eTypeIsArray))
1222 {
1223 // We have an array
1224 uint64_t array_size = 0;
1225 if (clang_type.IsArrayType(NULL, &array_size, NULL))
1226 {
1227 cstr_len = array_size;
1228 if (cstr_len > max_length)
1229 {
1230 capped_data = true;
1231 cstr_len = max_length;
1232 }
1233 }
1234 cstr_address = GetAddressOf (true, &cstr_address_type);
1235 }
1236 else
1237 {
1238 // We have a pointer
1239 cstr_address = GetPointerValue (&cstr_address_type);
1240 }
1241
1242 if (cstr_address == 0 || cstr_address == LLDB_INVALID_ADDRESS)
1243 {
1244 s << "<invalid address>";
1245 error.SetErrorString("invalid address");
1246 return 0;
1247 }
1248
1249 Address cstr_so_addr (cstr_address);
1250 DataExtractor data;
1251 if (cstr_len > 0 && honor_array)
1252 {
1253 // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host
1254 // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this
1255 GetPointeeData(data, 0, cstr_len);
1256
1257 if ((bytes_read = data.GetByteSize()) > 0)
1258 {
1259 total_bytes_read = bytes_read;
1260 s << '"';
1261 data.Dump (&s,
1262 0, // Start offset in "data"
1263 item_format,
1264 1, // Size of item (1 byte for a char!)
1265 bytes_read, // How many bytes to print?
1266 UINT32_MAX, // num per line
1267 LLDB_INVALID_ADDRESS,// base address
1268 0, // bitfield bit size
1269 0); // bitfield bit offset
1270 if (capped_data)
1271 s << "...";
1272 s << '"';
1273 }
1274 }
1275 else
1276 {
1277 cstr_len = max_length;
1278 const size_t k_max_buf_size = 64;
1279
1280 size_t offset = 0;
1281
1282 int cstr_len_displayed = -1;
1283 bool capped_cstr = false;
1284 // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host
1285 // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this
1286 while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0)
1287 {
1288 total_bytes_read += bytes_read;
1289 const char *cstr = data.PeekCStr(0);
1290 size_t len = strlen_or_inf (cstr, k_max_buf_size, k_max_buf_size+1);
1291 if (len > k_max_buf_size)
1292 len = k_max_buf_size;
1293 if (cstr && cstr_len_displayed < 0)
1294 s << '"';
1295
1296 if (cstr_len_displayed < 0)
1297 cstr_len_displayed = len;
1298
1299 if (len == 0)
1300 break;
1301 cstr_len_displayed += len;
1302 if (len > bytes_read)
1303 len = bytes_read;
1304 if (len > cstr_len)
1305 len = cstr_len;
1306
1307 data.Dump (&s,
1308 0, // Start offset in "data"
1309 item_format,
1310 1, // Size of item (1 byte for a char!)
1311 len, // How many bytes to print?
1312 UINT32_MAX, // num per line
1313 LLDB_INVALID_ADDRESS,// base address
1314 0, // bitfield bit size
1315 0); // bitfield bit offset
1316
1317 if (len < k_max_buf_size)
1318 break;
1319
1320 if (len >= cstr_len)
1321 {
1322 capped_cstr = true;
1323 break;
1324 }
1325
1326 cstr_len -= len;
1327 offset += len;
1328 }
1329
1330 if (cstr_len_displayed >= 0)
1331 {
1332 s << '"';
1333 if (capped_cstr)
1334 s << "...";
1335 }
1336 }
1337 }
1338 else
1339 {
1340 error.SetErrorString("not a string object");
1341 s << "<not a string object>";
1342 }
1343 return total_bytes_read;
1344 }
1345
1346 const char *
GetObjectDescription()1347 ValueObject::GetObjectDescription ()
1348 {
1349
1350 if (!UpdateValueIfNeeded (true))
1351 return NULL;
1352
1353 if (!m_object_desc_str.empty())
1354 return m_object_desc_str.c_str();
1355
1356 ExecutionContext exe_ctx (GetExecutionContextRef());
1357 Process *process = exe_ctx.GetProcessPtr();
1358 if (process == NULL)
1359 return NULL;
1360
1361 StreamString s;
1362
1363 LanguageType language = GetObjectRuntimeLanguage();
1364 LanguageRuntime *runtime = process->GetLanguageRuntime(language);
1365
1366 if (runtime == NULL)
1367 {
1368 // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway...
1369 ClangASTType clang_type = GetClangType();
1370 if (clang_type)
1371 {
1372 bool is_signed;
1373 if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType ())
1374 {
1375 runtime = process->GetLanguageRuntime(eLanguageTypeObjC);
1376 }
1377 }
1378 }
1379
1380 if (runtime && runtime->GetObjectDescription(s, *this))
1381 {
1382 m_object_desc_str.append (s.GetData());
1383 }
1384
1385 if (m_object_desc_str.empty())
1386 return NULL;
1387 else
1388 return m_object_desc_str.c_str();
1389 }
1390
1391 bool
GetValueAsCString(const lldb_private::TypeFormatImpl & format,std::string & destination)1392 ValueObject::GetValueAsCString (const lldb_private::TypeFormatImpl& format,
1393 std::string& destination)
1394 {
1395 if (UpdateValueIfNeeded(false))
1396 return format.FormatObject(this,destination);
1397 else
1398 return false;
1399 }
1400
1401 bool
GetValueAsCString(lldb::Format format,std::string & destination)1402 ValueObject::GetValueAsCString (lldb::Format format,
1403 std::string& destination)
1404 {
1405 return GetValueAsCString(TypeFormatImpl_Format(format),destination);
1406 }
1407
1408 const char *
GetValueAsCString()1409 ValueObject::GetValueAsCString ()
1410 {
1411 if (UpdateValueIfNeeded(true))
1412 {
1413 lldb::TypeFormatImplSP format_sp;
1414 lldb::Format my_format = GetFormat();
1415 if (my_format == lldb::eFormatDefault)
1416 {
1417 if (m_type_format_sp)
1418 format_sp = m_type_format_sp;
1419 else
1420 {
1421 if (m_is_bitfield_for_scalar)
1422 my_format = eFormatUnsigned;
1423 else
1424 {
1425 if (m_value.GetContextType() == Value::eContextTypeRegisterInfo)
1426 {
1427 const RegisterInfo *reg_info = m_value.GetRegisterInfo();
1428 if (reg_info)
1429 my_format = reg_info->format;
1430 }
1431 else
1432 {
1433 my_format = GetClangType().GetFormat();
1434 }
1435 }
1436 }
1437 }
1438 if (my_format != m_last_format || m_value_str.empty())
1439 {
1440 m_last_format = my_format;
1441 if (!format_sp)
1442 format_sp.reset(new TypeFormatImpl_Format(my_format));
1443 if (GetValueAsCString(*format_sp.get(), m_value_str))
1444 {
1445 if (!m_value_did_change && m_old_value_valid)
1446 {
1447 // The value was gotten successfully, so we consider the
1448 // value as changed if the value string differs
1449 SetValueDidChange (m_old_value_str != m_value_str);
1450 }
1451 }
1452 }
1453 }
1454 if (m_value_str.empty())
1455 return NULL;
1456 return m_value_str.c_str();
1457 }
1458
1459 // if > 8bytes, 0 is returned. this method should mostly be used
1460 // to read address values out of pointers
1461 uint64_t
GetValueAsUnsigned(uint64_t fail_value,bool * success)1462 ValueObject::GetValueAsUnsigned (uint64_t fail_value, bool *success)
1463 {
1464 // If our byte size is zero this is an aggregate type that has children
1465 if (!GetClangType().IsAggregateType())
1466 {
1467 Scalar scalar;
1468 if (ResolveValue (scalar))
1469 {
1470 if (success)
1471 *success = true;
1472 return scalar.ULongLong(fail_value);
1473 }
1474 // fallthrough, otherwise...
1475 }
1476
1477 if (success)
1478 *success = false;
1479 return fail_value;
1480 }
1481
1482 int64_t
GetValueAsSigned(int64_t fail_value,bool * success)1483 ValueObject::GetValueAsSigned (int64_t fail_value, bool *success)
1484 {
1485 // If our byte size is zero this is an aggregate type that has children
1486 if (!GetClangType().IsAggregateType())
1487 {
1488 Scalar scalar;
1489 if (ResolveValue (scalar))
1490 {
1491 if (success)
1492 *success = true;
1493 return scalar.SLongLong(fail_value);
1494 }
1495 // fallthrough, otherwise...
1496 }
1497
1498 if (success)
1499 *success = false;
1500 return fail_value;
1501 }
1502
1503 // if any more "special cases" are added to ValueObject::DumpPrintableRepresentation() please keep
1504 // this call up to date by returning true for your new special cases. We will eventually move
1505 // to checking this call result before trying to display special cases
1506 bool
HasSpecialPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display,Format custom_format)1507 ValueObject::HasSpecialPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display,
1508 Format custom_format)
1509 {
1510 Flags flags(GetTypeInfo());
1511 if (flags.AnySet(ClangASTType::eTypeIsArray | ClangASTType::eTypeIsPointer)
1512 && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue)
1513 {
1514 if (IsCStringContainer(true) &&
1515 (custom_format == eFormatCString ||
1516 custom_format == eFormatCharArray ||
1517 custom_format == eFormatChar ||
1518 custom_format == eFormatVectorOfChar))
1519 return true;
1520
1521 if (flags.Test(ClangASTType::eTypeIsArray))
1522 {
1523 if ((custom_format == eFormatBytes) ||
1524 (custom_format == eFormatBytesWithASCII))
1525 return true;
1526
1527 if ((custom_format == eFormatVectorOfChar) ||
1528 (custom_format == eFormatVectorOfFloat32) ||
1529 (custom_format == eFormatVectorOfFloat64) ||
1530 (custom_format == eFormatVectorOfSInt16) ||
1531 (custom_format == eFormatVectorOfSInt32) ||
1532 (custom_format == eFormatVectorOfSInt64) ||
1533 (custom_format == eFormatVectorOfSInt8) ||
1534 (custom_format == eFormatVectorOfUInt128) ||
1535 (custom_format == eFormatVectorOfUInt16) ||
1536 (custom_format == eFormatVectorOfUInt32) ||
1537 (custom_format == eFormatVectorOfUInt64) ||
1538 (custom_format == eFormatVectorOfUInt8))
1539 return true;
1540 }
1541 }
1542 return false;
1543 }
1544
1545 bool
DumpPrintableRepresentation(Stream & s,ValueObjectRepresentationStyle val_obj_display,Format custom_format,PrintableRepresentationSpecialCases special,bool do_dump_error)1546 ValueObject::DumpPrintableRepresentation(Stream& s,
1547 ValueObjectRepresentationStyle val_obj_display,
1548 Format custom_format,
1549 PrintableRepresentationSpecialCases special,
1550 bool do_dump_error)
1551 {
1552
1553 Flags flags(GetTypeInfo());
1554
1555 bool allow_special = ((special & ePrintableRepresentationSpecialCasesAllow) == ePrintableRepresentationSpecialCasesAllow);
1556 bool only_special = ((special & ePrintableRepresentationSpecialCasesOnly) == ePrintableRepresentationSpecialCasesOnly);
1557
1558 if (allow_special)
1559 {
1560 if (flags.AnySet(ClangASTType::eTypeIsArray | ClangASTType::eTypeIsPointer)
1561 && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue)
1562 {
1563 // when being asked to get a printable display an array or pointer type directly,
1564 // try to "do the right thing"
1565
1566 if (IsCStringContainer(true) &&
1567 (custom_format == eFormatCString ||
1568 custom_format == eFormatCharArray ||
1569 custom_format == eFormatChar ||
1570 custom_format == eFormatVectorOfChar)) // print char[] & char* directly
1571 {
1572 Error error;
1573 ReadPointedString(s,
1574 error,
1575 0,
1576 (custom_format == eFormatVectorOfChar) ||
1577 (custom_format == eFormatCharArray));
1578 return !error.Fail();
1579 }
1580
1581 if (custom_format == eFormatEnum)
1582 return false;
1583
1584 // this only works for arrays, because I have no way to know when
1585 // the pointed memory ends, and no special \0 end of data marker
1586 if (flags.Test(ClangASTType::eTypeIsArray))
1587 {
1588 if ((custom_format == eFormatBytes) ||
1589 (custom_format == eFormatBytesWithASCII))
1590 {
1591 const size_t count = GetNumChildren();
1592
1593 s << '[';
1594 for (size_t low = 0; low < count; low++)
1595 {
1596
1597 if (low)
1598 s << ',';
1599
1600 ValueObjectSP child = GetChildAtIndex(low,true);
1601 if (!child.get())
1602 {
1603 s << "<invalid child>";
1604 continue;
1605 }
1606 child->DumpPrintableRepresentation(s, ValueObject::eValueObjectRepresentationStyleValue, custom_format);
1607 }
1608
1609 s << ']';
1610
1611 return true;
1612 }
1613
1614 if ((custom_format == eFormatVectorOfChar) ||
1615 (custom_format == eFormatVectorOfFloat32) ||
1616 (custom_format == eFormatVectorOfFloat64) ||
1617 (custom_format == eFormatVectorOfSInt16) ||
1618 (custom_format == eFormatVectorOfSInt32) ||
1619 (custom_format == eFormatVectorOfSInt64) ||
1620 (custom_format == eFormatVectorOfSInt8) ||
1621 (custom_format == eFormatVectorOfUInt128) ||
1622 (custom_format == eFormatVectorOfUInt16) ||
1623 (custom_format == eFormatVectorOfUInt32) ||
1624 (custom_format == eFormatVectorOfUInt64) ||
1625 (custom_format == eFormatVectorOfUInt8)) // arrays of bytes, bytes with ASCII or any vector format should be printed directly
1626 {
1627 const size_t count = GetNumChildren();
1628
1629 Format format = FormatManager::GetSingleItemFormat(custom_format);
1630
1631 s << '[';
1632 for (size_t low = 0; low < count; low++)
1633 {
1634
1635 if (low)
1636 s << ',';
1637
1638 ValueObjectSP child = GetChildAtIndex(low,true);
1639 if (!child.get())
1640 {
1641 s << "<invalid child>";
1642 continue;
1643 }
1644 child->DumpPrintableRepresentation(s, ValueObject::eValueObjectRepresentationStyleValue, format);
1645 }
1646
1647 s << ']';
1648
1649 return true;
1650 }
1651 }
1652
1653 if ((custom_format == eFormatBoolean) ||
1654 (custom_format == eFormatBinary) ||
1655 (custom_format == eFormatChar) ||
1656 (custom_format == eFormatCharPrintable) ||
1657 (custom_format == eFormatComplexFloat) ||
1658 (custom_format == eFormatDecimal) ||
1659 (custom_format == eFormatHex) ||
1660 (custom_format == eFormatHexUppercase) ||
1661 (custom_format == eFormatFloat) ||
1662 (custom_format == eFormatOctal) ||
1663 (custom_format == eFormatOSType) ||
1664 (custom_format == eFormatUnicode16) ||
1665 (custom_format == eFormatUnicode32) ||
1666 (custom_format == eFormatUnsigned) ||
1667 (custom_format == eFormatPointer) ||
1668 (custom_format == eFormatComplexInteger) ||
1669 (custom_format == eFormatComplex) ||
1670 (custom_format == eFormatDefault)) // use the [] operator
1671 return false;
1672 }
1673 }
1674
1675 if (only_special)
1676 return false;
1677
1678 bool var_success = false;
1679
1680 {
1681 const char *cstr = NULL;
1682
1683 // this is a local stream that we are using to ensure that the data pointed to by cstr survives
1684 // long enough for us to copy it to its destination - it is necessary to have this temporary storage
1685 // area for cases where our desired output is not backed by some other longer-term storage
1686 StreamString strm;
1687
1688 if (custom_format != eFormatInvalid)
1689 SetFormat(custom_format);
1690
1691 switch(val_obj_display)
1692 {
1693 case eValueObjectRepresentationStyleValue:
1694 cstr = GetValueAsCString();
1695 break;
1696
1697 case eValueObjectRepresentationStyleSummary:
1698 cstr = GetSummaryAsCString();
1699 break;
1700
1701 case eValueObjectRepresentationStyleLanguageSpecific:
1702 cstr = GetObjectDescription();
1703 break;
1704
1705 case eValueObjectRepresentationStyleLocation:
1706 cstr = GetLocationAsCString();
1707 break;
1708
1709 case eValueObjectRepresentationStyleChildrenCount:
1710 strm.Printf("%zu", GetNumChildren());
1711 cstr = strm.GetString().c_str();
1712 break;
1713
1714 case eValueObjectRepresentationStyleType:
1715 cstr = GetTypeName().AsCString();
1716 break;
1717
1718 case eValueObjectRepresentationStyleName:
1719 cstr = GetName().AsCString();
1720 break;
1721
1722 case eValueObjectRepresentationStyleExpressionPath:
1723 GetExpressionPath(strm, false);
1724 cstr = strm.GetString().c_str();
1725 break;
1726 }
1727
1728 if (!cstr)
1729 {
1730 if (val_obj_display == eValueObjectRepresentationStyleValue)
1731 cstr = GetSummaryAsCString();
1732 else if (val_obj_display == eValueObjectRepresentationStyleSummary)
1733 {
1734 if (GetClangType().IsAggregateType())
1735 {
1736 strm.Printf("%s @ %s", GetTypeName().AsCString(), GetLocationAsCString());
1737 cstr = strm.GetString().c_str();
1738 }
1739 else
1740 cstr = GetValueAsCString();
1741 }
1742 }
1743
1744 if (cstr)
1745 s.PutCString(cstr);
1746 else
1747 {
1748 if (m_error.Fail())
1749 {
1750 if (do_dump_error)
1751 s.Printf("<%s>", m_error.AsCString());
1752 else
1753 return false;
1754 }
1755 else if (val_obj_display == eValueObjectRepresentationStyleSummary)
1756 s.PutCString("<no summary available>");
1757 else if (val_obj_display == eValueObjectRepresentationStyleValue)
1758 s.PutCString("<no value available>");
1759 else if (val_obj_display == eValueObjectRepresentationStyleLanguageSpecific)
1760 s.PutCString("<not a valid Objective-C object>"); // edit this if we have other runtimes that support a description
1761 else
1762 s.PutCString("<no printable representation>");
1763 }
1764
1765 // we should only return false here if we could not do *anything*
1766 // even if we have an error message as output, that's a success
1767 // from our callers' perspective, so return true
1768 var_success = true;
1769
1770 if (custom_format != eFormatInvalid)
1771 SetFormat(eFormatDefault);
1772 }
1773
1774 return var_success;
1775 }
1776
1777 addr_t
GetAddressOf(bool scalar_is_load_address,AddressType * address_type)1778 ValueObject::GetAddressOf (bool scalar_is_load_address, AddressType *address_type)
1779 {
1780 if (!UpdateValueIfNeeded(false))
1781 return LLDB_INVALID_ADDRESS;
1782
1783 switch (m_value.GetValueType())
1784 {
1785 case Value::eValueTypeScalar:
1786 case Value::eValueTypeVector:
1787 if (scalar_is_load_address)
1788 {
1789 if(address_type)
1790 *address_type = eAddressTypeLoad;
1791 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1792 }
1793 break;
1794
1795 case Value::eValueTypeLoadAddress:
1796 case Value::eValueTypeFileAddress:
1797 case Value::eValueTypeHostAddress:
1798 {
1799 if(address_type)
1800 *address_type = m_value.GetValueAddressType ();
1801 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1802 }
1803 break;
1804 }
1805 if (address_type)
1806 *address_type = eAddressTypeInvalid;
1807 return LLDB_INVALID_ADDRESS;
1808 }
1809
1810 addr_t
GetPointerValue(AddressType * address_type)1811 ValueObject::GetPointerValue (AddressType *address_type)
1812 {
1813 addr_t address = LLDB_INVALID_ADDRESS;
1814 if(address_type)
1815 *address_type = eAddressTypeInvalid;
1816
1817 if (!UpdateValueIfNeeded(false))
1818 return address;
1819
1820 switch (m_value.GetValueType())
1821 {
1822 case Value::eValueTypeScalar:
1823 case Value::eValueTypeVector:
1824 address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1825 break;
1826
1827 case Value::eValueTypeHostAddress:
1828 case Value::eValueTypeLoadAddress:
1829 case Value::eValueTypeFileAddress:
1830 {
1831 lldb::offset_t data_offset = 0;
1832 address = m_data.GetPointer(&data_offset);
1833 }
1834 break;
1835 }
1836
1837 if (address_type)
1838 *address_type = GetAddressTypeOfChildren();
1839
1840 return address;
1841 }
1842
1843 bool
SetValueFromCString(const char * value_str,Error & error)1844 ValueObject::SetValueFromCString (const char *value_str, Error& error)
1845 {
1846 error.Clear();
1847 // Make sure our value is up to date first so that our location and location
1848 // type is valid.
1849 if (!UpdateValueIfNeeded(false))
1850 {
1851 error.SetErrorString("unable to read value");
1852 return false;
1853 }
1854
1855 uint64_t count = 0;
1856 const Encoding encoding = GetClangType().GetEncoding (count);
1857
1858 const size_t byte_size = GetByteSize();
1859
1860 Value::ValueType value_type = m_value.GetValueType();
1861
1862 if (value_type == Value::eValueTypeScalar)
1863 {
1864 // If the value is already a scalar, then let the scalar change itself:
1865 m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size);
1866 }
1867 else if (byte_size <= Scalar::GetMaxByteSize())
1868 {
1869 // If the value fits in a scalar, then make a new scalar and again let the
1870 // scalar code do the conversion, then figure out where to put the new value.
1871 Scalar new_scalar;
1872 error = new_scalar.SetValueFromCString (value_str, encoding, byte_size);
1873 if (error.Success())
1874 {
1875 switch (value_type)
1876 {
1877 case Value::eValueTypeLoadAddress:
1878 {
1879 // If it is a load address, then the scalar value is the storage location
1880 // of the data, and we have to shove this value down to that load location.
1881 ExecutionContext exe_ctx (GetExecutionContextRef());
1882 Process *process = exe_ctx.GetProcessPtr();
1883 if (process)
1884 {
1885 addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1886 size_t bytes_written = process->WriteScalarToMemory (target_addr,
1887 new_scalar,
1888 byte_size,
1889 error);
1890 if (!error.Success())
1891 return false;
1892 if (bytes_written != byte_size)
1893 {
1894 error.SetErrorString("unable to write value to memory");
1895 return false;
1896 }
1897 }
1898 }
1899 break;
1900 case Value::eValueTypeHostAddress:
1901 {
1902 // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data.
1903 DataExtractor new_data;
1904 new_data.SetByteOrder (m_data.GetByteOrder());
1905
1906 DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0));
1907 m_data.SetData(buffer_sp, 0);
1908 bool success = new_scalar.GetData(new_data);
1909 if (success)
1910 {
1911 new_data.CopyByteOrderedData (0,
1912 byte_size,
1913 const_cast<uint8_t *>(m_data.GetDataStart()),
1914 byte_size,
1915 m_data.GetByteOrder());
1916 }
1917 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1918
1919 }
1920 break;
1921 case Value::eValueTypeFileAddress:
1922 case Value::eValueTypeScalar:
1923 case Value::eValueTypeVector:
1924 break;
1925 }
1926 }
1927 else
1928 {
1929 return false;
1930 }
1931 }
1932 else
1933 {
1934 // We don't support setting things bigger than a scalar at present.
1935 error.SetErrorString("unable to write aggregate data type");
1936 return false;
1937 }
1938
1939 // If we have reached this point, then we have successfully changed the value.
1940 SetNeedsUpdate();
1941 return true;
1942 }
1943
1944 bool
GetDeclaration(Declaration & decl)1945 ValueObject::GetDeclaration (Declaration &decl)
1946 {
1947 decl.Clear();
1948 return false;
1949 }
1950
1951 ConstString
GetTypeName()1952 ValueObject::GetTypeName()
1953 {
1954 return GetClangType().GetConstTypeName();
1955 }
1956
1957 ConstString
GetQualifiedTypeName()1958 ValueObject::GetQualifiedTypeName()
1959 {
1960 return GetClangType().GetConstQualifiedTypeName();
1961 }
1962
1963
1964 LanguageType
GetObjectRuntimeLanguage()1965 ValueObject::GetObjectRuntimeLanguage ()
1966 {
1967 return GetClangType().GetMinimumLanguage ();
1968 }
1969
1970 void
AddSyntheticChild(const ConstString & key,ValueObject * valobj)1971 ValueObject::AddSyntheticChild (const ConstString &key, ValueObject *valobj)
1972 {
1973 m_synthetic_children[key] = valobj;
1974 }
1975
1976 ValueObjectSP
GetSyntheticChild(const ConstString & key) const1977 ValueObject::GetSyntheticChild (const ConstString &key) const
1978 {
1979 ValueObjectSP synthetic_child_sp;
1980 std::map<ConstString, ValueObject *>::const_iterator pos = m_synthetic_children.find (key);
1981 if (pos != m_synthetic_children.end())
1982 synthetic_child_sp = pos->second->GetSP();
1983 return synthetic_child_sp;
1984 }
1985
1986 uint32_t
GetTypeInfo(ClangASTType * pointee_or_element_clang_type)1987 ValueObject::GetTypeInfo (ClangASTType *pointee_or_element_clang_type)
1988 {
1989 return GetClangType().GetTypeInfo (pointee_or_element_clang_type);
1990 }
1991
1992 bool
IsPointerType()1993 ValueObject::IsPointerType ()
1994 {
1995 return GetClangType().IsPointerType();
1996 }
1997
1998 bool
IsArrayType()1999 ValueObject::IsArrayType ()
2000 {
2001 return GetClangType().IsArrayType (NULL, NULL, NULL);
2002 }
2003
2004 bool
IsScalarType()2005 ValueObject::IsScalarType ()
2006 {
2007 return GetClangType().IsScalarType ();
2008 }
2009
2010 bool
IsIntegerType(bool & is_signed)2011 ValueObject::IsIntegerType (bool &is_signed)
2012 {
2013 return GetClangType().IsIntegerType (is_signed);
2014 }
2015
2016 bool
IsPointerOrReferenceType()2017 ValueObject::IsPointerOrReferenceType ()
2018 {
2019 return GetClangType().IsPointerOrReferenceType ();
2020 }
2021
2022 bool
IsPossibleDynamicType()2023 ValueObject::IsPossibleDynamicType ()
2024 {
2025 ExecutionContext exe_ctx (GetExecutionContextRef());
2026 Process *process = exe_ctx.GetProcessPtr();
2027 if (process)
2028 return process->IsPossibleDynamicValue(*this);
2029 else
2030 return GetClangType().IsPossibleDynamicType (NULL, true, true);
2031 }
2032
2033 bool
IsObjCNil()2034 ValueObject::IsObjCNil ()
2035 {
2036 const uint32_t mask = ClangASTType::eTypeIsObjC | ClangASTType::eTypeIsPointer;
2037 bool isObjCpointer = (((GetClangType().GetTypeInfo(NULL)) & mask) == mask);
2038 if (!isObjCpointer)
2039 return false;
2040 bool canReadValue = true;
2041 bool isZero = GetValueAsUnsigned(0,&canReadValue) == 0;
2042 return canReadValue && isZero;
2043 }
2044
2045 ValueObjectSP
GetSyntheticArrayMember(size_t index,bool can_create)2046 ValueObject::GetSyntheticArrayMember (size_t index, bool can_create)
2047 {
2048 const uint32_t type_info = GetTypeInfo ();
2049 if (type_info & ClangASTType::eTypeIsArray)
2050 return GetSyntheticArrayMemberFromArray(index, can_create);
2051
2052 if (type_info & ClangASTType::eTypeIsPointer)
2053 return GetSyntheticArrayMemberFromPointer(index, can_create);
2054
2055 return ValueObjectSP();
2056
2057 }
2058
2059 ValueObjectSP
GetSyntheticArrayMemberFromPointer(size_t index,bool can_create)2060 ValueObject::GetSyntheticArrayMemberFromPointer (size_t index, bool can_create)
2061 {
2062 ValueObjectSP synthetic_child_sp;
2063 if (IsPointerType ())
2064 {
2065 char index_str[64];
2066 snprintf(index_str, sizeof(index_str), "[%zu]", index);
2067 ConstString index_const_str(index_str);
2068 // Check if we have already created a synthetic array member in this
2069 // valid object. If we have we will re-use it.
2070 synthetic_child_sp = GetSyntheticChild (index_const_str);
2071 if (!synthetic_child_sp)
2072 {
2073 ValueObject *synthetic_child;
2074 // We haven't made a synthetic array member for INDEX yet, so
2075 // lets make one and cache it for any future reference.
2076 synthetic_child = CreateChildAtIndex(0, true, index);
2077
2078 // Cache the value if we got one back...
2079 if (synthetic_child)
2080 {
2081 AddSyntheticChild(index_const_str, synthetic_child);
2082 synthetic_child_sp = synthetic_child->GetSP();
2083 synthetic_child_sp->SetName(ConstString(index_str));
2084 synthetic_child_sp->m_is_array_item_for_pointer = true;
2085 }
2086 }
2087 }
2088 return synthetic_child_sp;
2089 }
2090
2091 // This allows you to create an array member using and index
2092 // that doesn't not fall in the normal bounds of the array.
2093 // Many times structure can be defined as:
2094 // struct Collection
2095 // {
2096 // uint32_t item_count;
2097 // Item item_array[0];
2098 // };
2099 // The size of the "item_array" is 1, but many times in practice
2100 // there are more items in "item_array".
2101
2102 ValueObjectSP
GetSyntheticArrayMemberFromArray(size_t index,bool can_create)2103 ValueObject::GetSyntheticArrayMemberFromArray (size_t index, bool can_create)
2104 {
2105 ValueObjectSP synthetic_child_sp;
2106 if (IsArrayType ())
2107 {
2108 char index_str[64];
2109 snprintf(index_str, sizeof(index_str), "[%zu]", index);
2110 ConstString index_const_str(index_str);
2111 // Check if we have already created a synthetic array member in this
2112 // valid object. If we have we will re-use it.
2113 synthetic_child_sp = GetSyntheticChild (index_const_str);
2114 if (!synthetic_child_sp)
2115 {
2116 ValueObject *synthetic_child;
2117 // We haven't made a synthetic array member for INDEX yet, so
2118 // lets make one and cache it for any future reference.
2119 synthetic_child = CreateChildAtIndex(0, true, index);
2120
2121 // Cache the value if we got one back...
2122 if (synthetic_child)
2123 {
2124 AddSyntheticChild(index_const_str, synthetic_child);
2125 synthetic_child_sp = synthetic_child->GetSP();
2126 synthetic_child_sp->SetName(ConstString(index_str));
2127 synthetic_child_sp->m_is_array_item_for_pointer = true;
2128 }
2129 }
2130 }
2131 return synthetic_child_sp;
2132 }
2133
2134 ValueObjectSP
GetSyntheticBitFieldChild(uint32_t from,uint32_t to,bool can_create)2135 ValueObject::GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_create)
2136 {
2137 ValueObjectSP synthetic_child_sp;
2138 if (IsScalarType ())
2139 {
2140 char index_str[64];
2141 snprintf(index_str, sizeof(index_str), "[%i-%i]", from, to);
2142 ConstString index_const_str(index_str);
2143 // Check if we have already created a synthetic array member in this
2144 // valid object. If we have we will re-use it.
2145 synthetic_child_sp = GetSyntheticChild (index_const_str);
2146 if (!synthetic_child_sp)
2147 {
2148 // We haven't made a synthetic array member for INDEX yet, so
2149 // lets make one and cache it for any future reference.
2150 ValueObjectChild *synthetic_child = new ValueObjectChild (*this,
2151 GetClangType(),
2152 index_const_str,
2153 GetByteSize(),
2154 0,
2155 to-from+1,
2156 from,
2157 false,
2158 false,
2159 eAddressTypeInvalid);
2160
2161 // Cache the value if we got one back...
2162 if (synthetic_child)
2163 {
2164 AddSyntheticChild(index_const_str, synthetic_child);
2165 synthetic_child_sp = synthetic_child->GetSP();
2166 synthetic_child_sp->SetName(ConstString(index_str));
2167 synthetic_child_sp->m_is_bitfield_for_scalar = true;
2168 }
2169 }
2170 }
2171 return synthetic_child_sp;
2172 }
2173
2174 ValueObjectSP
GetSyntheticChildAtOffset(uint32_t offset,const ClangASTType & type,bool can_create)2175 ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
2176 {
2177
2178 ValueObjectSP synthetic_child_sp;
2179
2180 char name_str[64];
2181 snprintf(name_str, sizeof(name_str), "@%i", offset);
2182 ConstString name_const_str(name_str);
2183
2184 // Check if we have already created a synthetic array member in this
2185 // valid object. If we have we will re-use it.
2186 synthetic_child_sp = GetSyntheticChild (name_const_str);
2187
2188 if (synthetic_child_sp.get())
2189 return synthetic_child_sp;
2190
2191 if (!can_create)
2192 return ValueObjectSP();
2193
2194 ValueObjectChild *synthetic_child = new ValueObjectChild(*this,
2195 type,
2196 name_const_str,
2197 type.GetByteSize(),
2198 offset,
2199 0,
2200 0,
2201 false,
2202 false,
2203 eAddressTypeInvalid);
2204 if (synthetic_child)
2205 {
2206 AddSyntheticChild(name_const_str, synthetic_child);
2207 synthetic_child_sp = synthetic_child->GetSP();
2208 synthetic_child_sp->SetName(name_const_str);
2209 synthetic_child_sp->m_is_child_at_offset = true;
2210 }
2211 return synthetic_child_sp;
2212 }
2213
2214 // your expression path needs to have a leading . or ->
2215 // (unless it somehow "looks like" an array, in which case it has
2216 // a leading [ symbol). while the [ is meaningful and should be shown
2217 // to the user, . and -> are just parser design, but by no means
2218 // added information for the user.. strip them off
2219 static const char*
SkipLeadingExpressionPathSeparators(const char * expression)2220 SkipLeadingExpressionPathSeparators(const char* expression)
2221 {
2222 if (!expression || !expression[0])
2223 return expression;
2224 if (expression[0] == '.')
2225 return expression+1;
2226 if (expression[0] == '-' && expression[1] == '>')
2227 return expression+2;
2228 return expression;
2229 }
2230
2231 ValueObjectSP
GetSyntheticExpressionPathChild(const char * expression,bool can_create)2232 ValueObject::GetSyntheticExpressionPathChild(const char* expression, bool can_create)
2233 {
2234 ValueObjectSP synthetic_child_sp;
2235 ConstString name_const_string(expression);
2236 // Check if we have already created a synthetic array member in this
2237 // valid object. If we have we will re-use it.
2238 synthetic_child_sp = GetSyntheticChild (name_const_string);
2239 if (!synthetic_child_sp)
2240 {
2241 // We haven't made a synthetic array member for expression yet, so
2242 // lets make one and cache it for any future reference.
2243 synthetic_child_sp = GetValueForExpressionPath(expression,
2244 NULL, NULL, NULL,
2245 GetValueForExpressionPathOptions().DontAllowSyntheticChildren());
2246
2247 // Cache the value if we got one back...
2248 if (synthetic_child_sp.get())
2249 {
2250 // FIXME: this causes a "real" child to end up with its name changed to the contents of expression
2251 AddSyntheticChild(name_const_string, synthetic_child_sp.get());
2252 synthetic_child_sp->SetName(ConstString(SkipLeadingExpressionPathSeparators(expression)));
2253 }
2254 }
2255 return synthetic_child_sp;
2256 }
2257
2258 void
CalculateSyntheticValue(bool use_synthetic)2259 ValueObject::CalculateSyntheticValue (bool use_synthetic)
2260 {
2261 if (use_synthetic == false)
2262 return;
2263
2264 TargetSP target_sp(GetTargetSP());
2265 if (target_sp && target_sp->GetEnableSyntheticValue() == false)
2266 {
2267 m_synthetic_value = NULL;
2268 return;
2269 }
2270
2271 lldb::SyntheticChildrenSP current_synth_sp(m_synthetic_children_sp);
2272
2273 if (!UpdateFormatsIfNeeded() && m_synthetic_value)
2274 return;
2275
2276 if (m_synthetic_children_sp.get() == NULL)
2277 return;
2278
2279 if (current_synth_sp == m_synthetic_children_sp && m_synthetic_value)
2280 return;
2281
2282 m_synthetic_value = new ValueObjectSynthetic(*this, m_synthetic_children_sp);
2283 }
2284
2285 void
CalculateDynamicValue(DynamicValueType use_dynamic)2286 ValueObject::CalculateDynamicValue (DynamicValueType use_dynamic)
2287 {
2288 if (use_dynamic == eNoDynamicValues)
2289 return;
2290
2291 if (!m_dynamic_value && !IsDynamic())
2292 {
2293 ExecutionContext exe_ctx (GetExecutionContextRef());
2294 Process *process = exe_ctx.GetProcessPtr();
2295 if (process && process->IsPossibleDynamicValue(*this))
2296 {
2297 ClearDynamicTypeInformation ();
2298 m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic);
2299 }
2300 }
2301 }
2302
2303 ValueObjectSP
GetDynamicValue(DynamicValueType use_dynamic)2304 ValueObject::GetDynamicValue (DynamicValueType use_dynamic)
2305 {
2306 if (use_dynamic == eNoDynamicValues)
2307 return ValueObjectSP();
2308
2309 if (!IsDynamic() && m_dynamic_value == NULL)
2310 {
2311 CalculateDynamicValue(use_dynamic);
2312 }
2313 if (m_dynamic_value)
2314 return m_dynamic_value->GetSP();
2315 else
2316 return ValueObjectSP();
2317 }
2318
2319 ValueObjectSP
GetStaticValue()2320 ValueObject::GetStaticValue()
2321 {
2322 return GetSP();
2323 }
2324
2325 lldb::ValueObjectSP
GetNonSyntheticValue()2326 ValueObject::GetNonSyntheticValue ()
2327 {
2328 return GetSP();
2329 }
2330
2331 ValueObjectSP
GetSyntheticValue(bool use_synthetic)2332 ValueObject::GetSyntheticValue (bool use_synthetic)
2333 {
2334 if (use_synthetic == false)
2335 return ValueObjectSP();
2336
2337 CalculateSyntheticValue(use_synthetic);
2338
2339 if (m_synthetic_value)
2340 return m_synthetic_value->GetSP();
2341 else
2342 return ValueObjectSP();
2343 }
2344
2345 bool
HasSyntheticValue()2346 ValueObject::HasSyntheticValue()
2347 {
2348 UpdateFormatsIfNeeded();
2349
2350 if (m_synthetic_children_sp.get() == NULL)
2351 return false;
2352
2353 CalculateSyntheticValue(true);
2354
2355 if (m_synthetic_value)
2356 return true;
2357 else
2358 return false;
2359 }
2360
2361 bool
GetBaseClassPath(Stream & s)2362 ValueObject::GetBaseClassPath (Stream &s)
2363 {
2364 if (IsBaseClass())
2365 {
2366 bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s);
2367 ClangASTType clang_type = GetClangType();
2368 std::string cxx_class_name;
2369 bool this_had_base_class = clang_type.GetCXXClassName (cxx_class_name);
2370 if (this_had_base_class)
2371 {
2372 if (parent_had_base_class)
2373 s.PutCString("::");
2374 s.PutCString(cxx_class_name.c_str());
2375 }
2376 return parent_had_base_class || this_had_base_class;
2377 }
2378 return false;
2379 }
2380
2381
2382 ValueObject *
GetNonBaseClassParent()2383 ValueObject::GetNonBaseClassParent()
2384 {
2385 if (GetParent())
2386 {
2387 if (GetParent()->IsBaseClass())
2388 return GetParent()->GetNonBaseClassParent();
2389 else
2390 return GetParent();
2391 }
2392 return NULL;
2393 }
2394
2395 void
GetExpressionPath(Stream & s,bool qualify_cxx_base_classes,GetExpressionPathFormat epformat)2396 ValueObject::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat)
2397 {
2398 const bool is_deref_of_parent = IsDereferenceOfParent ();
2399
2400 if (is_deref_of_parent && epformat == eGetExpressionPathFormatDereferencePointers)
2401 {
2402 // this is the original format of GetExpressionPath() producing code like *(a_ptr).memberName, which is entirely
2403 // fine, until you put this into StackFrame::GetValueForVariableExpressionPath() which prefers to see a_ptr->memberName.
2404 // the eHonorPointers mode is meant to produce strings in this latter format
2405 s.PutCString("*(");
2406 }
2407
2408 ValueObject* parent = GetParent();
2409
2410 if (parent)
2411 parent->GetExpressionPath (s, qualify_cxx_base_classes, epformat);
2412
2413 // if we are a deref_of_parent just because we are synthetic array
2414 // members made up to allow ptr[%d] syntax to work in variable
2415 // printing, then add our name ([%d]) to the expression path
2416 if (m_is_array_item_for_pointer && epformat == eGetExpressionPathFormatHonorPointers)
2417 s.PutCString(m_name.AsCString());
2418
2419 if (!IsBaseClass())
2420 {
2421 if (!is_deref_of_parent)
2422 {
2423 ValueObject *non_base_class_parent = GetNonBaseClassParent();
2424 if (non_base_class_parent)
2425 {
2426 ClangASTType non_base_class_parent_clang_type = non_base_class_parent->GetClangType();
2427 if (non_base_class_parent_clang_type)
2428 {
2429 if (parent && parent->IsDereferenceOfParent() && epformat == eGetExpressionPathFormatHonorPointers)
2430 {
2431 s.PutCString("->");
2432 }
2433 else
2434 {
2435 const uint32_t non_base_class_parent_type_info = non_base_class_parent_clang_type.GetTypeInfo();
2436
2437 if (non_base_class_parent_type_info & ClangASTType::eTypeIsPointer)
2438 {
2439 s.PutCString("->");
2440 }
2441 else if ((non_base_class_parent_type_info & ClangASTType::eTypeHasChildren) &&
2442 !(non_base_class_parent_type_info & ClangASTType::eTypeIsArray))
2443 {
2444 s.PutChar('.');
2445 }
2446 }
2447 }
2448 }
2449
2450 const char *name = GetName().GetCString();
2451 if (name)
2452 {
2453 if (qualify_cxx_base_classes)
2454 {
2455 if (GetBaseClassPath (s))
2456 s.PutCString("::");
2457 }
2458 s.PutCString(name);
2459 }
2460 }
2461 }
2462
2463 if (is_deref_of_parent && epformat == eGetExpressionPathFormatDereferencePointers)
2464 {
2465 s.PutChar(')');
2466 }
2467 }
2468
2469 ValueObjectSP
GetValueForExpressionPath(const char * expression,const char ** first_unparsed,ExpressionPathScanEndReason * reason_to_stop,ExpressionPathEndResultType * final_value_type,const GetValueForExpressionPathOptions & options,ExpressionPathAftermath * final_task_on_target)2470 ValueObject::GetValueForExpressionPath(const char* expression,
2471 const char** first_unparsed,
2472 ExpressionPathScanEndReason* reason_to_stop,
2473 ExpressionPathEndResultType* final_value_type,
2474 const GetValueForExpressionPathOptions& options,
2475 ExpressionPathAftermath* final_task_on_target)
2476 {
2477
2478 const char* dummy_first_unparsed;
2479 ExpressionPathScanEndReason dummy_reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnknown;
2480 ExpressionPathEndResultType dummy_final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2481 ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2482
2483 ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression,
2484 first_unparsed ? first_unparsed : &dummy_first_unparsed,
2485 reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2486 final_value_type ? final_value_type : &dummy_final_value_type,
2487 options,
2488 final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2489
2490 if (!final_task_on_target || *final_task_on_target == ValueObject::eExpressionPathAftermathNothing)
2491 return ret_val;
2492
2493 if (ret_val.get() && ((final_value_type ? *final_value_type : dummy_final_value_type) == eExpressionPathEndResultTypePlain)) // I can only deref and takeaddress of plain objects
2494 {
2495 if ( (final_task_on_target ? *final_task_on_target : dummy_final_task_on_target) == ValueObject::eExpressionPathAftermathDereference)
2496 {
2497 Error error;
2498 ValueObjectSP final_value = ret_val->Dereference(error);
2499 if (error.Fail() || !final_value.get())
2500 {
2501 if (reason_to_stop)
2502 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2503 if (final_value_type)
2504 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2505 return ValueObjectSP();
2506 }
2507 else
2508 {
2509 if (final_task_on_target)
2510 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2511 return final_value;
2512 }
2513 }
2514 if (*final_task_on_target == ValueObject::eExpressionPathAftermathTakeAddress)
2515 {
2516 Error error;
2517 ValueObjectSP final_value = ret_val->AddressOf(error);
2518 if (error.Fail() || !final_value.get())
2519 {
2520 if (reason_to_stop)
2521 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonTakingAddressFailed;
2522 if (final_value_type)
2523 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2524 return ValueObjectSP();
2525 }
2526 else
2527 {
2528 if (final_task_on_target)
2529 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2530 return final_value;
2531 }
2532 }
2533 }
2534 return ret_val; // final_task_on_target will still have its original value, so you know I did not do it
2535 }
2536
2537 int
GetValuesForExpressionPath(const char * expression,ValueObjectListSP & list,const char ** first_unparsed,ExpressionPathScanEndReason * reason_to_stop,ExpressionPathEndResultType * final_value_type,const GetValueForExpressionPathOptions & options,ExpressionPathAftermath * final_task_on_target)2538 ValueObject::GetValuesForExpressionPath(const char* expression,
2539 ValueObjectListSP& list,
2540 const char** first_unparsed,
2541 ExpressionPathScanEndReason* reason_to_stop,
2542 ExpressionPathEndResultType* final_value_type,
2543 const GetValueForExpressionPathOptions& options,
2544 ExpressionPathAftermath* final_task_on_target)
2545 {
2546 const char* dummy_first_unparsed;
2547 ExpressionPathScanEndReason dummy_reason_to_stop;
2548 ExpressionPathEndResultType dummy_final_value_type;
2549 ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2550
2551 ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression,
2552 first_unparsed ? first_unparsed : &dummy_first_unparsed,
2553 reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2554 final_value_type ? final_value_type : &dummy_final_value_type,
2555 options,
2556 final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2557
2558 if (!ret_val.get()) // if there are errors, I add nothing to the list
2559 return 0;
2560
2561 if ( (reason_to_stop ? *reason_to_stop : dummy_reason_to_stop) != eExpressionPathScanEndReasonArrayRangeOperatorMet)
2562 {
2563 // I need not expand a range, just post-process the final value and return
2564 if (!final_task_on_target || *final_task_on_target == ValueObject::eExpressionPathAftermathNothing)
2565 {
2566 list->Append(ret_val);
2567 return 1;
2568 }
2569 if (ret_val.get() && (final_value_type ? *final_value_type : dummy_final_value_type) == eExpressionPathEndResultTypePlain) // I can only deref and takeaddress of plain objects
2570 {
2571 if (*final_task_on_target == ValueObject::eExpressionPathAftermathDereference)
2572 {
2573 Error error;
2574 ValueObjectSP final_value = ret_val->Dereference(error);
2575 if (error.Fail() || !final_value.get())
2576 {
2577 if (reason_to_stop)
2578 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2579 if (final_value_type)
2580 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2581 return 0;
2582 }
2583 else
2584 {
2585 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2586 list->Append(final_value);
2587 return 1;
2588 }
2589 }
2590 if (*final_task_on_target == ValueObject::eExpressionPathAftermathTakeAddress)
2591 {
2592 Error error;
2593 ValueObjectSP final_value = ret_val->AddressOf(error);
2594 if (error.Fail() || !final_value.get())
2595 {
2596 if (reason_to_stop)
2597 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonTakingAddressFailed;
2598 if (final_value_type)
2599 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2600 return 0;
2601 }
2602 else
2603 {
2604 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2605 list->Append(final_value);
2606 return 1;
2607 }
2608 }
2609 }
2610 }
2611 else
2612 {
2613 return ExpandArraySliceExpression(first_unparsed ? *first_unparsed : dummy_first_unparsed,
2614 first_unparsed ? first_unparsed : &dummy_first_unparsed,
2615 ret_val,
2616 list,
2617 reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2618 final_value_type ? final_value_type : &dummy_final_value_type,
2619 options,
2620 final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2621 }
2622 // in any non-covered case, just do the obviously right thing
2623 list->Append(ret_val);
2624 return 1;
2625 }
2626
2627 ValueObjectSP
GetValueForExpressionPath_Impl(const char * expression_cstr,const char ** first_unparsed,ExpressionPathScanEndReason * reason_to_stop,ExpressionPathEndResultType * final_result,const GetValueForExpressionPathOptions & options,ExpressionPathAftermath * what_next)2628 ValueObject::GetValueForExpressionPath_Impl(const char* expression_cstr,
2629 const char** first_unparsed,
2630 ExpressionPathScanEndReason* reason_to_stop,
2631 ExpressionPathEndResultType* final_result,
2632 const GetValueForExpressionPathOptions& options,
2633 ExpressionPathAftermath* what_next)
2634 {
2635 ValueObjectSP root = GetSP();
2636
2637 if (!root.get())
2638 return ValueObjectSP();
2639
2640 *first_unparsed = expression_cstr;
2641
2642 while (true)
2643 {
2644
2645 const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
2646
2647 ClangASTType root_clang_type = root->GetClangType();
2648 ClangASTType pointee_clang_type;
2649 Flags pointee_clang_type_info;
2650
2651 Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type));
2652 if (pointee_clang_type)
2653 pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo());
2654
2655 if (!expression_cstr || *expression_cstr == '\0')
2656 {
2657 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2658 return root;
2659 }
2660
2661 switch (*expression_cstr)
2662 {
2663 case '-':
2664 {
2665 if (options.m_check_dot_vs_arrow_syntax &&
2666 root_clang_type_info.Test(ClangASTType::eTypeIsPointer) ) // if you are trying to use -> on a non-pointer and I must catch the error
2667 {
2668 *first_unparsed = expression_cstr;
2669 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot;
2670 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2671 return ValueObjectSP();
2672 }
2673 if (root_clang_type_info.Test(ClangASTType::eTypeIsObjC) && // if yo are trying to extract an ObjC IVar when this is forbidden
2674 root_clang_type_info.Test(ClangASTType::eTypeIsPointer) &&
2675 options.m_no_fragile_ivar)
2676 {
2677 *first_unparsed = expression_cstr;
2678 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonFragileIVarNotAllowed;
2679 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2680 return ValueObjectSP();
2681 }
2682 if (expression_cstr[1] != '>')
2683 {
2684 *first_unparsed = expression_cstr;
2685 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2686 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2687 return ValueObjectSP();
2688 }
2689 expression_cstr++; // skip the -
2690 }
2691 case '.': // or fallthrough from ->
2692 {
2693 if (options.m_check_dot_vs_arrow_syntax && *expression_cstr == '.' &&
2694 root_clang_type_info.Test(ClangASTType::eTypeIsPointer)) // if you are trying to use . on a pointer and I must catch the error
2695 {
2696 *first_unparsed = expression_cstr;
2697 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow;
2698 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2699 return ValueObjectSP();
2700 }
2701 expression_cstr++; // skip .
2702 const char *next_separator = strpbrk(expression_cstr+1,"-.[");
2703 ConstString child_name;
2704 if (!next_separator) // if no other separator just expand this last layer
2705 {
2706 child_name.SetCString (expression_cstr);
2707 ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true);
2708
2709 if (child_valobj_sp.get()) // we know we are done, so just return
2710 {
2711 *first_unparsed = "";
2712 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2713 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2714 return child_valobj_sp;
2715 }
2716 else if (options.m_no_synthetic_children == false) // let's try with synthetic children
2717 {
2718 if (root->IsSynthetic())
2719 {
2720 *first_unparsed = expression_cstr;
2721 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2722 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2723 return ValueObjectSP();
2724 }
2725
2726 child_valobj_sp = root->GetSyntheticValue();
2727 if (child_valobj_sp.get())
2728 child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2729 }
2730
2731 // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP,
2732 // so we hit the "else" branch, and return an error
2733 if(child_valobj_sp.get()) // if it worked, just return
2734 {
2735 *first_unparsed = "";
2736 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2737 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2738 return child_valobj_sp;
2739 }
2740 else
2741 {
2742 *first_unparsed = expression_cstr;
2743 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2744 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2745 return ValueObjectSP();
2746 }
2747 }
2748 else // other layers do expand
2749 {
2750 child_name.SetCStringWithLength(expression_cstr, next_separator - expression_cstr);
2751 ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true);
2752 if (child_valobj_sp.get()) // store the new root and move on
2753 {
2754 root = child_valobj_sp;
2755 *first_unparsed = next_separator;
2756 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2757 continue;
2758 }
2759 else if (options.m_no_synthetic_children == false) // let's try with synthetic children
2760 {
2761 if (root->IsSynthetic())
2762 {
2763 *first_unparsed = expression_cstr;
2764 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2765 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2766 return ValueObjectSP();
2767 }
2768
2769 child_valobj_sp = root->GetSyntheticValue(true);
2770 if (child_valobj_sp)
2771 child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2772 }
2773
2774 // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP,
2775 // so we hit the "else" branch, and return an error
2776 if(child_valobj_sp.get()) // if it worked, move on
2777 {
2778 root = child_valobj_sp;
2779 *first_unparsed = next_separator;
2780 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2781 continue;
2782 }
2783 else
2784 {
2785 *first_unparsed = expression_cstr;
2786 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2787 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2788 return ValueObjectSP();
2789 }
2790 }
2791 break;
2792 }
2793 case '[':
2794 {
2795 if (!root_clang_type_info.Test(ClangASTType::eTypeIsArray) && !root_clang_type_info.Test(ClangASTType::eTypeIsPointer) && !root_clang_type_info.Test(ClangASTType::eTypeIsVector)) // if this is not a T[] nor a T*
2796 {
2797 if (!root_clang_type_info.Test(ClangASTType::eTypeIsScalar)) // if this is not even a scalar...
2798 {
2799 if (options.m_no_synthetic_children) // ...only chance left is synthetic
2800 {
2801 *first_unparsed = expression_cstr;
2802 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
2803 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2804 return ValueObjectSP();
2805 }
2806 }
2807 else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
2808 {
2809 *first_unparsed = expression_cstr;
2810 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
2811 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2812 return ValueObjectSP();
2813 }
2814 }
2815 if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
2816 {
2817 if (!root_clang_type_info.Test(ClangASTType::eTypeIsArray))
2818 {
2819 *first_unparsed = expression_cstr;
2820 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
2821 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2822 return ValueObjectSP();
2823 }
2824 else // even if something follows, we cannot expand unbounded ranges, just let the caller do it
2825 {
2826 *first_unparsed = expression_cstr+2;
2827 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2828 *final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange;
2829 return root;
2830 }
2831 }
2832 const char *separator_position = ::strchr(expression_cstr+1,'-');
2833 const char *close_bracket_position = ::strchr(expression_cstr+1,']');
2834 if (!close_bracket_position) // if there is no ], this is a syntax error
2835 {
2836 *first_unparsed = expression_cstr;
2837 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2838 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2839 return ValueObjectSP();
2840 }
2841 if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N]
2842 {
2843 char *end = NULL;
2844 unsigned long index = ::strtoul (expression_cstr+1, &end, 0);
2845 if (!end || end != close_bracket_position) // if something weird is in our way return an error
2846 {
2847 *first_unparsed = expression_cstr;
2848 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2849 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2850 return ValueObjectSP();
2851 }
2852 if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
2853 {
2854 if (root_clang_type_info.Test(ClangASTType::eTypeIsArray))
2855 {
2856 *first_unparsed = expression_cstr+2;
2857 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2858 *final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange;
2859 return root;
2860 }
2861 else
2862 {
2863 *first_unparsed = expression_cstr;
2864 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
2865 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2866 return ValueObjectSP();
2867 }
2868 }
2869 // from here on we do have a valid index
2870 if (root_clang_type_info.Test(ClangASTType::eTypeIsArray))
2871 {
2872 ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
2873 if (!child_valobj_sp)
2874 child_valobj_sp = root->GetSyntheticArrayMemberFromArray(index, true);
2875 if (!child_valobj_sp)
2876 if (root->HasSyntheticValue() && root->GetSyntheticValue()->GetNumChildren() > index)
2877 child_valobj_sp = root->GetSyntheticValue()->GetChildAtIndex(index, true);
2878 if (child_valobj_sp)
2879 {
2880 root = child_valobj_sp;
2881 *first_unparsed = end+1; // skip ]
2882 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2883 continue;
2884 }
2885 else
2886 {
2887 *first_unparsed = expression_cstr;
2888 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2889 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2890 return ValueObjectSP();
2891 }
2892 }
2893 else if (root_clang_type_info.Test(ClangASTType::eTypeIsPointer))
2894 {
2895 if (*what_next == ValueObject::eExpressionPathAftermathDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
2896 pointee_clang_type_info.Test(ClangASTType::eTypeIsScalar))
2897 {
2898 Error error;
2899 root = root->Dereference(error);
2900 if (error.Fail() || !root.get())
2901 {
2902 *first_unparsed = expression_cstr;
2903 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2904 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2905 return ValueObjectSP();
2906 }
2907 else
2908 {
2909 *what_next = eExpressionPathAftermathNothing;
2910 continue;
2911 }
2912 }
2913 else
2914 {
2915 if (root->GetClangType().GetMinimumLanguage() == eLanguageTypeObjC
2916 && pointee_clang_type_info.AllClear(ClangASTType::eTypeIsPointer)
2917 && root->HasSyntheticValue()
2918 && options.m_no_synthetic_children == false)
2919 {
2920 root = root->GetSyntheticValue()->GetChildAtIndex(index, true);
2921 }
2922 else
2923 root = root->GetSyntheticArrayMemberFromPointer(index, true);
2924 if (!root.get())
2925 {
2926 *first_unparsed = expression_cstr;
2927 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2928 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2929 return ValueObjectSP();
2930 }
2931 else
2932 {
2933 *first_unparsed = end+1; // skip ]
2934 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2935 continue;
2936 }
2937 }
2938 }
2939 else if (root_clang_type_info.Test(ClangASTType::eTypeIsScalar))
2940 {
2941 root = root->GetSyntheticBitFieldChild(index, index, true);
2942 if (!root.get())
2943 {
2944 *first_unparsed = expression_cstr;
2945 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2946 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2947 return ValueObjectSP();
2948 }
2949 else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
2950 {
2951 *first_unparsed = end+1; // skip ]
2952 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
2953 *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
2954 return root;
2955 }
2956 }
2957 else if (root_clang_type_info.Test(ClangASTType::eTypeIsVector))
2958 {
2959 root = root->GetChildAtIndex(index, true);
2960 if (!root.get())
2961 {
2962 *first_unparsed = expression_cstr;
2963 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2964 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2965 return ValueObjectSP();
2966 }
2967 else
2968 {
2969 *first_unparsed = end+1; // skip ]
2970 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2971 continue;
2972 }
2973 }
2974 else if (options.m_no_synthetic_children == false)
2975 {
2976 if (root->HasSyntheticValue())
2977 root = root->GetSyntheticValue();
2978 else if (!root->IsSynthetic())
2979 {
2980 *first_unparsed = expression_cstr;
2981 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
2982 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2983 return ValueObjectSP();
2984 }
2985 // if we are here, then root itself is a synthetic VO.. should be good to go
2986
2987 if (!root.get())
2988 {
2989 *first_unparsed = expression_cstr;
2990 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
2991 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2992 return ValueObjectSP();
2993 }
2994 root = root->GetChildAtIndex(index, true);
2995 if (!root.get())
2996 {
2997 *first_unparsed = expression_cstr;
2998 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2999 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3000 return ValueObjectSP();
3001 }
3002 else
3003 {
3004 *first_unparsed = end+1; // skip ]
3005 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
3006 continue;
3007 }
3008 }
3009 else
3010 {
3011 *first_unparsed = expression_cstr;
3012 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3013 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3014 return ValueObjectSP();
3015 }
3016 }
3017 else // we have a low and a high index
3018 {
3019 char *end = NULL;
3020 unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0);
3021 if (!end || end != separator_position) // if something weird is in our way return an error
3022 {
3023 *first_unparsed = expression_cstr;
3024 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3025 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3026 return ValueObjectSP();
3027 }
3028 unsigned long index_higher = ::strtoul (separator_position+1, &end, 0);
3029 if (!end || end != close_bracket_position) // if something weird is in our way return an error
3030 {
3031 *first_unparsed = expression_cstr;
3032 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3033 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3034 return ValueObjectSP();
3035 }
3036 if (index_lower > index_higher) // swap indices if required
3037 {
3038 unsigned long temp = index_lower;
3039 index_lower = index_higher;
3040 index_higher = temp;
3041 }
3042 if (root_clang_type_info.Test(ClangASTType::eTypeIsScalar)) // expansion only works for scalars
3043 {
3044 root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
3045 if (!root.get())
3046 {
3047 *first_unparsed = expression_cstr;
3048 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3049 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3050 return ValueObjectSP();
3051 }
3052 else
3053 {
3054 *first_unparsed = end+1; // skip ]
3055 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
3056 *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
3057 return root;
3058 }
3059 }
3060 else if (root_clang_type_info.Test(ClangASTType::eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3061 *what_next == ValueObject::eExpressionPathAftermathDereference &&
3062 pointee_clang_type_info.Test(ClangASTType::eTypeIsScalar))
3063 {
3064 Error error;
3065 root = root->Dereference(error);
3066 if (error.Fail() || !root.get())
3067 {
3068 *first_unparsed = expression_cstr;
3069 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3070 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3071 return ValueObjectSP();
3072 }
3073 else
3074 {
3075 *what_next = ValueObject::eExpressionPathAftermathNothing;
3076 continue;
3077 }
3078 }
3079 else
3080 {
3081 *first_unparsed = expression_cstr;
3082 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
3083 *final_result = ValueObject::eExpressionPathEndResultTypeBoundedRange;
3084 return root;
3085 }
3086 }
3087 break;
3088 }
3089 default: // some non-separator is in the way
3090 {
3091 *first_unparsed = expression_cstr;
3092 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3093 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3094 return ValueObjectSP();
3095 break;
3096 }
3097 }
3098 }
3099 }
3100
3101 int
ExpandArraySliceExpression(const char * expression_cstr,const char ** first_unparsed,ValueObjectSP root,ValueObjectListSP & list,ExpressionPathScanEndReason * reason_to_stop,ExpressionPathEndResultType * final_result,const GetValueForExpressionPathOptions & options,ExpressionPathAftermath * what_next)3102 ValueObject::ExpandArraySliceExpression(const char* expression_cstr,
3103 const char** first_unparsed,
3104 ValueObjectSP root,
3105 ValueObjectListSP& list,
3106 ExpressionPathScanEndReason* reason_to_stop,
3107 ExpressionPathEndResultType* final_result,
3108 const GetValueForExpressionPathOptions& options,
3109 ExpressionPathAftermath* what_next)
3110 {
3111 if (!root.get())
3112 return 0;
3113
3114 *first_unparsed = expression_cstr;
3115
3116 while (true)
3117 {
3118
3119 const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
3120
3121 ClangASTType root_clang_type = root->GetClangType();
3122 ClangASTType pointee_clang_type;
3123 Flags pointee_clang_type_info;
3124 Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type));
3125 if (pointee_clang_type)
3126 pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo());
3127
3128 if (!expression_cstr || *expression_cstr == '\0')
3129 {
3130 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
3131 list->Append(root);
3132 return 1;
3133 }
3134
3135 switch (*expression_cstr)
3136 {
3137 case '[':
3138 {
3139 if (!root_clang_type_info.Test(ClangASTType::eTypeIsArray) && !root_clang_type_info.Test(ClangASTType::eTypeIsPointer)) // if this is not a T[] nor a T*
3140 {
3141 if (!root_clang_type_info.Test(ClangASTType::eTypeIsScalar)) // if this is not even a scalar, this syntax is just plain wrong!
3142 {
3143 *first_unparsed = expression_cstr;
3144 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
3145 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3146 return 0;
3147 }
3148 else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
3149 {
3150 *first_unparsed = expression_cstr;
3151 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
3152 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3153 return 0;
3154 }
3155 }
3156 if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
3157 {
3158 if (!root_clang_type_info.Test(ClangASTType::eTypeIsArray))
3159 {
3160 *first_unparsed = expression_cstr;
3161 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
3162 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3163 return 0;
3164 }
3165 else // expand this into list
3166 {
3167 const size_t max_index = root->GetNumChildren() - 1;
3168 for (size_t index = 0; index < max_index; index++)
3169 {
3170 ValueObjectSP child =
3171 root->GetChildAtIndex(index, true);
3172 list->Append(child);
3173 }
3174 *first_unparsed = expression_cstr+2;
3175 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3176 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3177 return max_index; // tell me number of items I added to the VOList
3178 }
3179 }
3180 const char *separator_position = ::strchr(expression_cstr+1,'-');
3181 const char *close_bracket_position = ::strchr(expression_cstr+1,']');
3182 if (!close_bracket_position) // if there is no ], this is a syntax error
3183 {
3184 *first_unparsed = expression_cstr;
3185 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3186 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3187 return 0;
3188 }
3189 if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N]
3190 {
3191 char *end = NULL;
3192 unsigned long index = ::strtoul (expression_cstr+1, &end, 0);
3193 if (!end || end != close_bracket_position) // if something weird is in our way return an error
3194 {
3195 *first_unparsed = expression_cstr;
3196 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3197 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3198 return 0;
3199 }
3200 if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
3201 {
3202 if (root_clang_type_info.Test(ClangASTType::eTypeIsArray))
3203 {
3204 const size_t max_index = root->GetNumChildren() - 1;
3205 for (size_t index = 0; index < max_index; index++)
3206 {
3207 ValueObjectSP child =
3208 root->GetChildAtIndex(index, true);
3209 list->Append(child);
3210 }
3211 *first_unparsed = expression_cstr+2;
3212 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3213 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3214 return max_index; // tell me number of items I added to the VOList
3215 }
3216 else
3217 {
3218 *first_unparsed = expression_cstr;
3219 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
3220 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3221 return 0;
3222 }
3223 }
3224 // from here on we do have a valid index
3225 if (root_clang_type_info.Test(ClangASTType::eTypeIsArray))
3226 {
3227 root = root->GetChildAtIndex(index, true);
3228 if (!root.get())
3229 {
3230 *first_unparsed = expression_cstr;
3231 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3232 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3233 return 0;
3234 }
3235 else
3236 {
3237 list->Append(root);
3238 *first_unparsed = end+1; // skip ]
3239 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3240 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3241 return 1;
3242 }
3243 }
3244 else if (root_clang_type_info.Test(ClangASTType::eTypeIsPointer))
3245 {
3246 if (*what_next == ValueObject::eExpressionPathAftermathDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3247 pointee_clang_type_info.Test(ClangASTType::eTypeIsScalar))
3248 {
3249 Error error;
3250 root = root->Dereference(error);
3251 if (error.Fail() || !root.get())
3252 {
3253 *first_unparsed = expression_cstr;
3254 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3255 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3256 return 0;
3257 }
3258 else
3259 {
3260 *what_next = eExpressionPathAftermathNothing;
3261 continue;
3262 }
3263 }
3264 else
3265 {
3266 root = root->GetSyntheticArrayMemberFromPointer(index, true);
3267 if (!root.get())
3268 {
3269 *first_unparsed = expression_cstr;
3270 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3271 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3272 return 0;
3273 }
3274 else
3275 {
3276 list->Append(root);
3277 *first_unparsed = end+1; // skip ]
3278 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3279 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3280 return 1;
3281 }
3282 }
3283 }
3284 else /*if (ClangASTContext::IsScalarType(root_clang_type))*/
3285 {
3286 root = root->GetSyntheticBitFieldChild(index, index, true);
3287 if (!root.get())
3288 {
3289 *first_unparsed = expression_cstr;
3290 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3291 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3292 return 0;
3293 }
3294 else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
3295 {
3296 list->Append(root);
3297 *first_unparsed = end+1; // skip ]
3298 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3299 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3300 return 1;
3301 }
3302 }
3303 }
3304 else // we have a low and a high index
3305 {
3306 char *end = NULL;
3307 unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0);
3308 if (!end || end != separator_position) // if something weird is in our way return an error
3309 {
3310 *first_unparsed = expression_cstr;
3311 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3312 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3313 return 0;
3314 }
3315 unsigned long index_higher = ::strtoul (separator_position+1, &end, 0);
3316 if (!end || end != close_bracket_position) // if something weird is in our way return an error
3317 {
3318 *first_unparsed = expression_cstr;
3319 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3320 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3321 return 0;
3322 }
3323 if (index_lower > index_higher) // swap indices if required
3324 {
3325 unsigned long temp = index_lower;
3326 index_lower = index_higher;
3327 index_higher = temp;
3328 }
3329 if (root_clang_type_info.Test(ClangASTType::eTypeIsScalar)) // expansion only works for scalars
3330 {
3331 root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
3332 if (!root.get())
3333 {
3334 *first_unparsed = expression_cstr;
3335 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3336 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3337 return 0;
3338 }
3339 else
3340 {
3341 list->Append(root);
3342 *first_unparsed = end+1; // skip ]
3343 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3344 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3345 return 1;
3346 }
3347 }
3348 else if (root_clang_type_info.Test(ClangASTType::eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3349 *what_next == ValueObject::eExpressionPathAftermathDereference &&
3350 pointee_clang_type_info.Test(ClangASTType::eTypeIsScalar))
3351 {
3352 Error error;
3353 root = root->Dereference(error);
3354 if (error.Fail() || !root.get())
3355 {
3356 *first_unparsed = expression_cstr;
3357 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3358 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3359 return 0;
3360 }
3361 else
3362 {
3363 *what_next = ValueObject::eExpressionPathAftermathNothing;
3364 continue;
3365 }
3366 }
3367 else
3368 {
3369 for (unsigned long index = index_lower;
3370 index <= index_higher; index++)
3371 {
3372 ValueObjectSP child =
3373 root->GetChildAtIndex(index, true);
3374 list->Append(child);
3375 }
3376 *first_unparsed = end+1;
3377 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3378 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3379 return index_higher-index_lower+1; // tell me number of items I added to the VOList
3380 }
3381 }
3382 break;
3383 }
3384 default: // some non-[ separator, or something entirely wrong, is in the way
3385 {
3386 *first_unparsed = expression_cstr;
3387 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3388 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3389 return 0;
3390 break;
3391 }
3392 }
3393 }
3394 }
3395
3396 void
LogValueObject(Log * log)3397 ValueObject::LogValueObject (Log *log)
3398 {
3399 if (log)
3400 return LogValueObject (log, DumpValueObjectOptions::DefaultOptions());
3401 }
3402
3403 void
LogValueObject(Log * log,const DumpValueObjectOptions & options)3404 ValueObject::LogValueObject (Log *log, const DumpValueObjectOptions& options)
3405 {
3406 if (log)
3407 {
3408 StreamString s;
3409 Dump (s, options);
3410 if (s.GetSize())
3411 log->PutCString(s.GetData());
3412 }
3413 }
3414
3415 void
Dump(Stream & s)3416 ValueObject::Dump (Stream &s)
3417 {
3418
3419 ValueObjectPrinter printer(this,&s,DumpValueObjectOptions::DefaultOptions());
3420 printer.PrintValueObject();
3421 }
3422
3423 void
Dump(Stream & s,const DumpValueObjectOptions & options)3424 ValueObject::Dump (Stream &s,
3425 const DumpValueObjectOptions& options)
3426 {
3427 ValueObjectPrinter printer(this,&s,options);
3428 printer.PrintValueObject();
3429 }
3430
3431 ValueObjectSP
CreateConstantValue(const ConstString & name)3432 ValueObject::CreateConstantValue (const ConstString &name)
3433 {
3434 ValueObjectSP valobj_sp;
3435
3436 if (UpdateValueIfNeeded(false) && m_error.Success())
3437 {
3438 ExecutionContext exe_ctx (GetExecutionContextRef());
3439
3440 DataExtractor data;
3441 data.SetByteOrder (m_data.GetByteOrder());
3442 data.SetAddressByteSize(m_data.GetAddressByteSize());
3443
3444 if (IsBitfield())
3445 {
3446 Value v(Scalar(GetValueAsUnsigned(UINT64_MAX)));
3447 m_error = v.GetValueAsData (&exe_ctx, data, 0, GetModule().get());
3448 }
3449 else
3450 m_error = m_value.GetValueAsData (&exe_ctx, data, 0, GetModule().get());
3451
3452 valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
3453 GetClangType(),
3454 name,
3455 data,
3456 GetAddressOf());
3457 }
3458
3459 if (!valobj_sp)
3460 {
3461 ExecutionContext exe_ctx (GetExecutionContextRef());
3462 valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), m_error);
3463 }
3464 return valobj_sp;
3465 }
3466
3467 ValueObjectSP
Dereference(Error & error)3468 ValueObject::Dereference (Error &error)
3469 {
3470 if (m_deref_valobj)
3471 return m_deref_valobj->GetSP();
3472
3473 const bool is_pointer_type = IsPointerType();
3474 if (is_pointer_type)
3475 {
3476 bool omit_empty_base_classes = true;
3477 bool ignore_array_bounds = false;
3478
3479 std::string child_name_str;
3480 uint32_t child_byte_size = 0;
3481 int32_t child_byte_offset = 0;
3482 uint32_t child_bitfield_bit_size = 0;
3483 uint32_t child_bitfield_bit_offset = 0;
3484 bool child_is_base_class = false;
3485 bool child_is_deref_of_parent = false;
3486 const bool transparent_pointers = false;
3487 ClangASTType clang_type = GetClangType();
3488 ClangASTType child_clang_type;
3489
3490 ExecutionContext exe_ctx (GetExecutionContextRef());
3491
3492 child_clang_type = clang_type.GetChildClangTypeAtIndex (&exe_ctx,
3493 GetName().GetCString(),
3494 0,
3495 transparent_pointers,
3496 omit_empty_base_classes,
3497 ignore_array_bounds,
3498 child_name_str,
3499 child_byte_size,
3500 child_byte_offset,
3501 child_bitfield_bit_size,
3502 child_bitfield_bit_offset,
3503 child_is_base_class,
3504 child_is_deref_of_parent);
3505 if (child_clang_type && child_byte_size)
3506 {
3507 ConstString child_name;
3508 if (!child_name_str.empty())
3509 child_name.SetCString (child_name_str.c_str());
3510
3511 m_deref_valobj = new ValueObjectChild (*this,
3512 child_clang_type,
3513 child_name,
3514 child_byte_size,
3515 child_byte_offset,
3516 child_bitfield_bit_size,
3517 child_bitfield_bit_offset,
3518 child_is_base_class,
3519 child_is_deref_of_parent,
3520 eAddressTypeInvalid);
3521 }
3522 }
3523
3524 if (m_deref_valobj)
3525 {
3526 error.Clear();
3527 return m_deref_valobj->GetSP();
3528 }
3529 else
3530 {
3531 StreamString strm;
3532 GetExpressionPath(strm, true);
3533
3534 if (is_pointer_type)
3535 error.SetErrorStringWithFormat("dereference failed: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str());
3536 else
3537 error.SetErrorStringWithFormat("not a pointer type: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str());
3538 return ValueObjectSP();
3539 }
3540 }
3541
3542 ValueObjectSP
AddressOf(Error & error)3543 ValueObject::AddressOf (Error &error)
3544 {
3545 if (m_addr_of_valobj_sp)
3546 return m_addr_of_valobj_sp;
3547
3548 AddressType address_type = eAddressTypeInvalid;
3549 const bool scalar_is_load_address = false;
3550 addr_t addr = GetAddressOf (scalar_is_load_address, &address_type);
3551 error.Clear();
3552 if (addr != LLDB_INVALID_ADDRESS)
3553 {
3554 switch (address_type)
3555 {
3556 case eAddressTypeInvalid:
3557 {
3558 StreamString expr_path_strm;
3559 GetExpressionPath(expr_path_strm, true);
3560 error.SetErrorStringWithFormat("'%s' is not in memory", expr_path_strm.GetString().c_str());
3561 }
3562 break;
3563
3564 case eAddressTypeFile:
3565 case eAddressTypeLoad:
3566 case eAddressTypeHost:
3567 {
3568 ClangASTType clang_type = GetClangType();
3569 if (clang_type)
3570 {
3571 std::string name (1, '&');
3572 name.append (m_name.AsCString(""));
3573 ExecutionContext exe_ctx (GetExecutionContextRef());
3574 m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
3575 clang_type.GetPointerType(),
3576 ConstString (name.c_str()),
3577 addr,
3578 eAddressTypeInvalid,
3579 m_data.GetAddressByteSize());
3580 }
3581 }
3582 break;
3583 }
3584 }
3585 else
3586 {
3587 StreamString expr_path_strm;
3588 GetExpressionPath(expr_path_strm, true);
3589 error.SetErrorStringWithFormat("'%s' doesn't have a valid address", expr_path_strm.GetString().c_str());
3590 }
3591
3592 return m_addr_of_valobj_sp;
3593 }
3594
3595 ValueObjectSP
Cast(const ClangASTType & clang_ast_type)3596 ValueObject::Cast (const ClangASTType &clang_ast_type)
3597 {
3598 return ValueObjectCast::Create (*this, GetName(), clang_ast_type);
3599 }
3600
3601 ValueObjectSP
CastPointerType(const char * name,ClangASTType & clang_ast_type)3602 ValueObject::CastPointerType (const char *name, ClangASTType &clang_ast_type)
3603 {
3604 ValueObjectSP valobj_sp;
3605 AddressType address_type;
3606 addr_t ptr_value = GetPointerValue (&address_type);
3607
3608 if (ptr_value != LLDB_INVALID_ADDRESS)
3609 {
3610 Address ptr_addr (ptr_value);
3611 ExecutionContext exe_ctx (GetExecutionContextRef());
3612 valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(),
3613 name,
3614 ptr_addr,
3615 clang_ast_type);
3616 }
3617 return valobj_sp;
3618 }
3619
3620 ValueObjectSP
CastPointerType(const char * name,TypeSP & type_sp)3621 ValueObject::CastPointerType (const char *name, TypeSP &type_sp)
3622 {
3623 ValueObjectSP valobj_sp;
3624 AddressType address_type;
3625 addr_t ptr_value = GetPointerValue (&address_type);
3626
3627 if (ptr_value != LLDB_INVALID_ADDRESS)
3628 {
3629 Address ptr_addr (ptr_value);
3630 ExecutionContext exe_ctx (GetExecutionContextRef());
3631 valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(),
3632 name,
3633 ptr_addr,
3634 type_sp);
3635 }
3636 return valobj_sp;
3637 }
3638
EvaluationPoint()3639 ValueObject::EvaluationPoint::EvaluationPoint () :
3640 m_mod_id(),
3641 m_exe_ctx_ref(),
3642 m_needs_update (true),
3643 m_first_update (true)
3644 {
3645 }
3646
EvaluationPoint(ExecutionContextScope * exe_scope,bool use_selected)3647 ValueObject::EvaluationPoint::EvaluationPoint (ExecutionContextScope *exe_scope, bool use_selected):
3648 m_mod_id(),
3649 m_exe_ctx_ref(),
3650 m_needs_update (true),
3651 m_first_update (true)
3652 {
3653 ExecutionContext exe_ctx(exe_scope);
3654 TargetSP target_sp (exe_ctx.GetTargetSP());
3655 if (target_sp)
3656 {
3657 m_exe_ctx_ref.SetTargetSP (target_sp);
3658 ProcessSP process_sp (exe_ctx.GetProcessSP());
3659 if (!process_sp)
3660 process_sp = target_sp->GetProcessSP();
3661
3662 if (process_sp)
3663 {
3664 m_mod_id = process_sp->GetModID();
3665 m_exe_ctx_ref.SetProcessSP (process_sp);
3666
3667 ThreadSP thread_sp (exe_ctx.GetThreadSP());
3668
3669 if (!thread_sp)
3670 {
3671 if (use_selected)
3672 thread_sp = process_sp->GetThreadList().GetSelectedThread();
3673 }
3674
3675 if (thread_sp)
3676 {
3677 m_exe_ctx_ref.SetThreadSP(thread_sp);
3678
3679 StackFrameSP frame_sp (exe_ctx.GetFrameSP());
3680 if (!frame_sp)
3681 {
3682 if (use_selected)
3683 frame_sp = thread_sp->GetSelectedFrame();
3684 }
3685 if (frame_sp)
3686 m_exe_ctx_ref.SetFrameSP(frame_sp);
3687 }
3688 }
3689 }
3690 }
3691
EvaluationPoint(const ValueObject::EvaluationPoint & rhs)3692 ValueObject::EvaluationPoint::EvaluationPoint (const ValueObject::EvaluationPoint &rhs) :
3693 m_mod_id(),
3694 m_exe_ctx_ref(rhs.m_exe_ctx_ref),
3695 m_needs_update (true),
3696 m_first_update (true)
3697 {
3698 }
3699
~EvaluationPoint()3700 ValueObject::EvaluationPoint::~EvaluationPoint ()
3701 {
3702 }
3703
3704 // This function checks the EvaluationPoint against the current process state. If the current
3705 // state matches the evaluation point, or the evaluation point is already invalid, then we return
3706 // false, meaning "no change". If the current state is different, we update our state, and return
3707 // true meaning "yes, change". If we did see a change, we also set m_needs_update to true, so
3708 // future calls to NeedsUpdate will return true.
3709 // exe_scope will be set to the current execution context scope.
3710
3711 bool
SyncWithProcessState()3712 ValueObject::EvaluationPoint::SyncWithProcessState()
3713 {
3714
3715 // Start with the target, if it is NULL, then we're obviously not going to get any further:
3716 const bool thread_and_frame_only_if_stopped = true;
3717 ExecutionContext exe_ctx(m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped));
3718
3719 if (exe_ctx.GetTargetPtr() == NULL)
3720 return false;
3721
3722 // If we don't have a process nothing can change.
3723 Process *process = exe_ctx.GetProcessPtr();
3724 if (process == NULL)
3725 return false;
3726
3727 // If our stop id is the current stop ID, nothing has changed:
3728 ProcessModID current_mod_id = process->GetModID();
3729
3730 // If the current stop id is 0, either we haven't run yet, or the process state has been cleared.
3731 // In either case, we aren't going to be able to sync with the process state.
3732 if (current_mod_id.GetStopID() == 0)
3733 return false;
3734
3735 bool changed = false;
3736 const bool was_valid = m_mod_id.IsValid();
3737 if (was_valid)
3738 {
3739 if (m_mod_id == current_mod_id)
3740 {
3741 // Everything is already up to date in this object, no need to
3742 // update the execution context scope.
3743 changed = false;
3744 }
3745 else
3746 {
3747 m_mod_id = current_mod_id;
3748 m_needs_update = true;
3749 changed = true;
3750 }
3751 }
3752
3753 // Now re-look up the thread and frame in case the underlying objects have gone away & been recreated.
3754 // That way we'll be sure to return a valid exe_scope.
3755 // If we used to have a thread or a frame but can't find it anymore, then mark ourselves as invalid.
3756
3757 if (m_exe_ctx_ref.HasThreadRef())
3758 {
3759 ThreadSP thread_sp (m_exe_ctx_ref.GetThreadSP());
3760 if (thread_sp)
3761 {
3762 if (m_exe_ctx_ref.HasFrameRef())
3763 {
3764 StackFrameSP frame_sp (m_exe_ctx_ref.GetFrameSP());
3765 if (!frame_sp)
3766 {
3767 // We used to have a frame, but now it is gone
3768 SetInvalid();
3769 changed = was_valid;
3770 }
3771 }
3772 }
3773 else
3774 {
3775 // We used to have a thread, but now it is gone
3776 SetInvalid();
3777 changed = was_valid;
3778 }
3779
3780 }
3781 return changed;
3782 }
3783
3784 void
SetUpdated()3785 ValueObject::EvaluationPoint::SetUpdated ()
3786 {
3787 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
3788 if (process_sp)
3789 m_mod_id = process_sp->GetModID();
3790 m_first_update = false;
3791 m_needs_update = false;
3792 }
3793
3794
3795
3796 void
ClearUserVisibleData(uint32_t clear_mask)3797 ValueObject::ClearUserVisibleData(uint32_t clear_mask)
3798 {
3799 if ((clear_mask & eClearUserVisibleDataItemsValue) == eClearUserVisibleDataItemsValue)
3800 m_value_str.clear();
3801
3802 if ((clear_mask & eClearUserVisibleDataItemsLocation) == eClearUserVisibleDataItemsLocation)
3803 m_location_str.clear();
3804
3805 if ((clear_mask & eClearUserVisibleDataItemsSummary) == eClearUserVisibleDataItemsSummary)
3806 {
3807 m_summary_str.clear();
3808 }
3809
3810 if ((clear_mask & eClearUserVisibleDataItemsDescription) == eClearUserVisibleDataItemsDescription)
3811 m_object_desc_str.clear();
3812
3813 if ((clear_mask & eClearUserVisibleDataItemsSyntheticChildren) == eClearUserVisibleDataItemsSyntheticChildren)
3814 {
3815 if (m_synthetic_value)
3816 m_synthetic_value = NULL;
3817 }
3818 }
3819
3820 SymbolContextScope *
GetSymbolContextScope()3821 ValueObject::GetSymbolContextScope()
3822 {
3823 if (m_parent)
3824 {
3825 if (!m_parent->IsPointerOrReferenceType())
3826 return m_parent->GetSymbolContextScope();
3827 }
3828 return NULL;
3829 }
3830
3831 lldb::ValueObjectSP
CreateValueObjectFromExpression(const char * name,const char * expression,const ExecutionContext & exe_ctx)3832 ValueObject::CreateValueObjectFromExpression (const char* name,
3833 const char* expression,
3834 const ExecutionContext& exe_ctx)
3835 {
3836 lldb::ValueObjectSP retval_sp;
3837 lldb::TargetSP target_sp(exe_ctx.GetTargetSP());
3838 if (!target_sp)
3839 return retval_sp;
3840 if (!expression || !*expression)
3841 return retval_sp;
3842 target_sp->EvaluateExpression (expression,
3843 exe_ctx.GetFrameSP().get(),
3844 retval_sp);
3845 if (retval_sp && name && *name)
3846 retval_sp->SetName(ConstString(name));
3847 return retval_sp;
3848 }
3849
3850 lldb::ValueObjectSP
CreateValueObjectFromAddress(const char * name,uint64_t address,const ExecutionContext & exe_ctx,ClangASTType type)3851 ValueObject::CreateValueObjectFromAddress (const char* name,
3852 uint64_t address,
3853 const ExecutionContext& exe_ctx,
3854 ClangASTType type)
3855 {
3856 if (type)
3857 {
3858 ClangASTType pointer_type(type.GetPointerType());
3859 if (pointer_type)
3860 {
3861 lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
3862 lldb::ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
3863 pointer_type,
3864 ConstString(name),
3865 buffer,
3866 lldb::endian::InlHostByteOrder(),
3867 exe_ctx.GetAddressByteSize()));
3868 if (ptr_result_valobj_sp)
3869 {
3870 ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
3871 Error err;
3872 ptr_result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
3873 if (ptr_result_valobj_sp && name && *name)
3874 ptr_result_valobj_sp->SetName(ConstString(name));
3875 }
3876 return ptr_result_valobj_sp;
3877 }
3878 }
3879 return lldb::ValueObjectSP();
3880 }
3881
3882 lldb::ValueObjectSP
CreateValueObjectFromData(const char * name,DataExtractor & data,const ExecutionContext & exe_ctx,ClangASTType type)3883 ValueObject::CreateValueObjectFromData (const char* name,
3884 DataExtractor& data,
3885 const ExecutionContext& exe_ctx,
3886 ClangASTType type)
3887 {
3888 lldb::ValueObjectSP new_value_sp;
3889 new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
3890 type,
3891 ConstString(name),
3892 data,
3893 LLDB_INVALID_ADDRESS);
3894 new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
3895 if (new_value_sp && name && *name)
3896 new_value_sp->SetName(ConstString(name));
3897 return new_value_sp;
3898 }
3899
3900 ModuleSP
GetModule()3901 ValueObject::GetModule ()
3902 {
3903 ValueObject* root(GetRoot());
3904 if (root != this)
3905 return root->GetModule();
3906 return lldb::ModuleSP();
3907 }
3908
3909 ValueObject*
GetRoot()3910 ValueObject::GetRoot ()
3911 {
3912 if (m_root)
3913 return m_root;
3914 ValueObject* parent = m_parent;
3915 if (!parent)
3916 return (m_root = this);
3917 while (parent->m_parent)
3918 {
3919 if (parent->m_root)
3920 return (m_root = parent->m_root);
3921 parent = parent->m_parent;
3922 }
3923 return (m_root = parent);
3924 }
3925
3926 AddressType
GetAddressTypeOfChildren()3927 ValueObject::GetAddressTypeOfChildren()
3928 {
3929 if (m_address_type_of_ptr_or_ref_children == eAddressTypeInvalid)
3930 {
3931 ValueObject* root(GetRoot());
3932 if (root != this)
3933 return root->GetAddressTypeOfChildren();
3934 }
3935 return m_address_type_of_ptr_or_ref_children;
3936 }
3937
3938 lldb::DynamicValueType
GetDynamicValueType()3939 ValueObject::GetDynamicValueType ()
3940 {
3941 ValueObject* with_dv_info = this;
3942 while (with_dv_info)
3943 {
3944 if (with_dv_info->HasDynamicValueTypeInfo())
3945 return with_dv_info->GetDynamicValueTypeImpl();
3946 with_dv_info = with_dv_info->m_parent;
3947 }
3948 return lldb::eNoDynamicValues;
3949 }
3950
3951 lldb::Format
GetFormat() const3952 ValueObject::GetFormat () const
3953 {
3954 const ValueObject* with_fmt_info = this;
3955 while (with_fmt_info)
3956 {
3957 if (with_fmt_info->m_format != lldb::eFormatDefault)
3958 return with_fmt_info->m_format;
3959 with_fmt_info = with_fmt_info->m_parent;
3960 }
3961 return m_format;
3962 }
3963