[lldb] Default can_create to true in GetChildAtIndex (NFC)

[kastiglione]

Summary

Existing callers of GetChildAtIndex pass true for can_create. This change
makes true the default value, callers don't have to pass an opaque true.

See also D151966 for the same change to GetChildMemberWithName.

[jingham]

I can dream up a few speculative uses of can_create => false but they are all a little far-fetched. Certainly passing true is the dominant mode, so making it a default seems fine to me and reduces a bunch of noise.

lldb/include/lldb/Core/ValueObject.h

public:
   // The functions below should NOT be modified by subclasses
   const Status &GetError();
 
   ConstString GetName() const { return m_name; }
 
   /// Returns a unique id for this ValueObject.
   lldb::user_id_t GetID() const { return m_id.GetID(); }
 
-  virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create);
+  virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx,
+                                              bool can_create = true);
 
   // this will always create the children if necessary
   lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
                                           size_t *index_of_error = nullptr);
 
   lldb::ValueObjectSP
   GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t, bool>> idxs,
                       size_t *index_of_error = nullptr);

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

public:
   ConstString GetDisplayTypeName() override;
 
   bool MightHaveChildren() override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   lldb::ValueType GetValueType() const override;
 
-  lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override;
+  lldb::ValueObjectSP GetChildAtIndex(size_t idx,
+                                      bool can_create = true) override;
 
   lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create = true) override;
 
   size_t GetIndexOfChildWithName(llvm::StringRef name) override;
 
   lldb::ValueObjectSP
   GetDynamicValue(lldb::DynamicValueType valueType) override;

lldb/source/API/SBValue.cpp

SBValue SBValue::GetChildAtIndex(uint32_t idx,
   LLDB_INSTRUMENT_VA(this, idx, use_dynamic, can_create_synthetic);
 
   lldb::ValueObjectSP child_sp;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     const bool can_create = true;
-    child_sp = value_sp->GetChildAtIndex(idx, can_create);
+    child_sp = value_sp->GetChildAtIndex(idx);
     if (can_create_synthetic && !child_sp) {
       child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
     }
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
 

lldb/source/Core/IOHandlerCursesGUI.cpp

std::vector<Row> &GetChildren() {
     }
     if (!calculated_children) {
       children.clear();
       calculated_children = true;
       ValueObjectSP valobj = value.GetSP();
       if (valobj) {
         const size_t num_children = valobj->GetNumChildren();
         for (size_t i = 0; i < num_children; ++i) {
-          children.push_back(Row(valobj->GetChildAtIndex(i, true), this));
+          children.push_back(Row(valobj->GetChildAtIndex(i), this));
         }
       }
     }
     return children;
   }
 
   void Unexpand() {
     expanded = false;

lldb/source/Core/ValueObject.cpp

 
 lldb::ValueObjectSP
 ValueObject::GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
                                  size_t *index_of_error) {
   if (idxs.size() == 0)
     return GetSP();
   ValueObjectSP root(GetSP());
   for (size_t idx : idxs) {
-    root = root->GetChildAtIndex(idx, true);
+    root = root->GetChildAtIndex(idx);
     if (!root) {
       if (index_of_error)
         *index_of_error = idx;
       return root;
     }
   }
   return root;
 }
size_t ValueObject::GetPointeeData(DataExtractor &data, uint32_t item_idx,
   {
     if (is_pointer_type) {
       Status error;
       ValueObjectSP pointee_sp = Dereference(error);
       if (error.Fail() || pointee_sp.get() == nullptr)
         return 0;
       return pointee_sp->GetData(data, error);
     } else {
-      ValueObjectSP child_sp = GetChildAtIndex(0, true);
+      ValueObjectSP child_sp = GetChildAtIndex(0);
       if (child_sp.get() == nullptr)
         return 0;
       Status error;
       return child_sp->GetData(data, error);
     }
     return true;
   } else /* (items > 1) */
   {
if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
           const size_t count = GetNumChildren();
 
           s << '[';
           for (size_t low = 0; low < count; low++) {
 
             if (low)
               s << ',';
 
-            ValueObjectSP child = GetChildAtIndex(low, true);
+            ValueObjectSP child = GetChildAtIndex(low);
             if (!child.get()) {
               s << "<invalid child>";
               continue;
             }
             child->DumpPrintableRepresentation(
                 s, ValueObject::eValueObjectRepresentationStyleValue,
                 custom_format);
           }
if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
           Format format = FormatManager::GetSingleItemFormat(custom_format);
 
           s << '[';
           for (size_t low = 0; low < count; low++) {
 
             if (low)
               s << ',';
 
-            ValueObjectSP child = GetChildAtIndex(low, true);
+            ValueObjectSP child = GetChildAtIndex(low);
             if (!child.get()) {
               s << "<invalid child>";
               continue;
             }
             child->DumpPrintableRepresentation(
                 s, ValueObject::eValueObjectRepresentationStyleValue, format);
           }
 
case '[': {
           *reason_to_stop =
               ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
           *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
           return nullptr;
         }
 
         // from here on we do have a valid index
         if (root_compiler_type_info.Test(eTypeIsArray)) {
-          ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
+          ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index);
           if (!child_valobj_sp)
             child_valobj_sp = root->GetSyntheticArrayMember(index, true);
           if (!child_valobj_sp)
             if (root->HasSyntheticValue() &&
                 root->GetSyntheticValue()->GetNumChildren() > index)
               child_valobj_sp =
-                  root->GetSyntheticValue()->GetChildAtIndex(index, true);
+                  root->GetSyntheticValue()->GetChildAtIndex(index);
           if (child_valobj_sp) {
             root = child_valobj_sp;
             remainder =
                 temp_expression.substr(close_bracket_position + 1); // skip ]
             *final_result = ValueObject::eExpressionPathEndResultTypePlain;
             continue;
           } else {
             *reason_to_stop =
case '[': {
                 pointee_compiler_type_info.AllClear(eTypeIsPointer) &&
                 root->HasSyntheticValue() &&
                 (options.m_synthetic_children_traversal ==
                      GetValueForExpressionPathOptions::
                          SyntheticChildrenTraversal::ToSynthetic ||
                  options.m_synthetic_children_traversal ==
                      GetValueForExpressionPathOptions::
                          SyntheticChildrenTraversal::Both)) {
-              root = root->GetSyntheticValue()->GetChildAtIndex(index, true);
+              root = root->GetSyntheticValue()->GetChildAtIndex(index);
             } else
               root = root->GetSyntheticArrayMember(index, true);
             if (!root) {
               *reason_to_stop =
                   ValueObject::eExpressionPathScanEndReasonNoSuchChild;
               *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
               return nullptr;
             } else {
case '[': {
                  // just return and let the caller do any further processing
           {
             *reason_to_stop = ValueObject::
                 eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
             *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
             return root;
           }
         } else if (root_compiler_type_info.Test(eTypeIsVector)) {
-          root = root->GetChildAtIndex(index, true);
+          root = root->GetChildAtIndex(index);
           if (!root) {
             *reason_to_stop =
                 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
             return ValueObjectSP();
           } else {
             remainder =
                 temp_expression.substr(close_bracket_position + 1); // skip ]
case '[': {
           // good to go
 
           if (!root) {
             *reason_to_stop =
                 ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
             return nullptr;
           }
-          root = root->GetChildAtIndex(index, true);
+          root = root->GetChildAtIndex(index);
           if (!root) {
             *reason_to_stop =
                 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
             return nullptr;
           } else {
             remainder =
                 temp_expression.substr(close_bracket_position + 1); // skip ]

lldb/source/Core/ValueObjectSyntheticFilter.cpp

 class DummySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   DummySyntheticFrontEnd(ValueObject &backend)
       : SyntheticChildrenFrontEnd(backend) {}
 
   size_t CalculateNumChildren() override { return m_backend.GetNumChildren(); }
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
-    return m_backend.GetChildAtIndex(idx, true);
+    return m_backend.GetChildAtIndex(idx);
   }
 
   size_t GetIndexOfChildWithName(ConstString name) override {
     return m_backend.GetIndexOfChildWithName(name);
   }
 
   bool MightHaveChildren() override { return true; }
 

lldb/source/DataFormatters/FormatManager.cpp

case eLazyBoolCalculate:
       break;
     }
   }
 
   size_t total_children_name_len = 0;
 
   for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
     bool is_synth_val = false;
-    ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
+    ValueObjectSP child_sp(valobj.GetChildAtIndex(idx));
     // something is wrong here - bail out
     if (!child_sp)
       return false;
 
     // also ask the child's type if it has any opinion
     CompilerType child_compiler_type(child_sp->GetCompilerType());
     if (child_compiler_type.IsValid()) {
       switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {

lldb/source/DataFormatters/ValueObjectPrinter.cpp

if (m_options.m_pointer_as_array) {
     // if generating pointer-as-array children, use GetSyntheticArrayMember
     return synth_valobj->GetSyntheticArrayMember(
         PhysicalIndexForLogicalIndex(
             m_options.m_pointer_as_array.m_base_element,
             m_options.m_pointer_as_array.m_stride, idx),
         true);
   } else {
     // otherwise, do the usual thing
-    return synth_valobj->GetChildAtIndex(idx, true);
+    return synth_valobj->GetChildAtIndex(idx);
   }
 }
 
 void ValueObjectPrinter::PrintChildren(
     bool value_printed, bool summary_printed,
     const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
   ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
 
bool ValueObjectPrinter::PrintChildrenOneLiner(bool hide_names) {
   bool print_dotdotdot = false;
   size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
 
   if (num_children) {
     m_stream->PutChar('(');
 
     bool did_print_children = false;
     for (uint32_t idx = 0; idx < num_children; ++idx) {
-      lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
+      lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx));
       if (child_sp)
         child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
             m_options.m_use_dynamic, m_options.m_use_synthetic);
       if (child_sp) {
         if (m_options.m_child_printing_decider &&
             !m_options.m_child_printing_decider(child_sp->GetName()))
           continue;
         if (idx && did_print_children)

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

 // representing the lambda closure whose members are the captured variables.
 void AddLambdaCaptureDecls(StreamString &stream, StackFrame *frame,
                            TokenVerifier const &verifier) {
   assert(frame);
 
   if (auto thisValSP = ClangExpressionUtil::GetLambdaValueObject(frame)) {
     uint32_t numChildren = thisValSP->GetNumChildren();
     for (uint32_t i = 0; i < numChildren; ++i) {
-      auto childVal = thisValSP->GetChildAtIndex(i, true);
+      auto childVal = thisValSP->GetChildAtIndex(i);
       ConstString childName(childVal ? childVal->GetName() : ConstString(""));
 
       if (!childName.IsEmpty() && verifier.hasToken(childName.GetStringRef()) &&
           childName != "this") {
         stream.Printf("using $__lldb_local_vars::%s;\n",
                       childName.GetCString());
       }
     }

lldb/source/Plugins/InstrumentationRuntime/TSan/InstrumentationRuntimeTSan.cpp

 CreateStackTrace(ValueObjectSP o,
                  const std::string &trace_item_name = ".trace") {
   auto trace_sp = std::make_shared<StructuredData::Array>();
   ValueObjectSP trace_value_object =
       o->GetValueForExpressionPath(trace_item_name.c_str());
   size_t count = trace_value_object->GetNumChildren();
   for (size_t j = 0; j < count; j++) {
     addr_t trace_addr =
-        trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
+        trace_value_object->GetChildAtIndex(j)->GetValueAsUnsigned(0);
     if (trace_addr == 0)
       break;
     trace_sp->AddIntegerItem(trace_addr);
   }
   return trace_sp;
 }
 
 static StructuredData::ArraySP ConvertToStructuredArray(
     ValueObjectSP return_value_sp, const std::string &items_name,
     const std::string &count_name,
     std::function<void(const ValueObjectSP &o,
                        const StructuredData::DictionarySP &dict)> const
         &callback) {
   auto array_sp = std::make_shared<StructuredData::Array>();
   unsigned int count =
       return_value_sp->GetValueForExpressionPath(count_name.c_str())
           ->GetValueAsUnsigned(0);
   ValueObjectSP objects =
       return_value_sp->GetValueForExpressionPath(items_name.c_str());
   for (unsigned int i = 0; i < count; i++) {
-    ValueObjectSP o = objects->GetChildAtIndex(i, true);
+    ValueObjectSP o = objects->GetChildAtIndex(i);
     auto dict_sp = std::make_shared<StructuredData::Dictionary>();
 
     callback(o, dict_sp);
 
     array_sp->AddItem(dict_sp);
   }
   return array_sp;
 }

lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp

 static lldb::addr_t GetCoroFramePtrFromHandle(ValueObjectSP valobj_sp) {
   if (!valobj_sp)
     return LLDB_INVALID_ADDRESS;
 
   // We expect a single pointer in the `coroutine_handle` class.
   // We don't care about its name.
   if (valobj_sp->GetNumChildren() != 1)
     return LLDB_INVALID_ADDRESS;
-  ValueObjectSP ptr_sp(valobj_sp->GetChildAtIndex(0, true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildAtIndex(0));
   if (!ptr_sp)
     return LLDB_INVALID_ADDRESS;
   if (!ptr_sp->GetCompilerType().IsPointerType())
     return LLDB_INVALID_ADDRESS;
 
   AddressType addr_type;
   lldb::addr_t frame_ptr_addr = ptr_sp->GetPointerValue(&addr_type);
   if (!frame_ptr_addr || frame_ptr_addr == LLDB_INVALID_ADDRESS)

lldb/source/Plugins/Language/CPlusPlus/GenericBitset.cpp

ValueObjectSP GenericBitsetFrontEnd::GetChildAtIndex(size_t idx) {
   CompilerType type;
   ValueObjectSP chunk;
   // For small bitsets __first_ is not an array, but a plain size_t.
   if (m_first->GetCompilerType().IsArrayType(&type)) {
     std::optional<uint64_t> bit_size =
         type.GetBitSize(ctx.GetBestExecutionContextScope());
     if (!bit_size || *bit_size == 0)
       return {};
-    chunk = m_first->GetChildAtIndex(idx / *bit_size, true);
+    chunk = m_first->GetChildAtIndex(idx / *bit_size);
   } else {
     type = m_first->GetCompilerType();
     chunk = m_first->GetSP();
   }
   if (!type || !chunk)
     return {};
 
   std::optional<uint64_t> bit_size =

lldb/source/Plugins/Language/CPlusPlus/GenericOptional.cpp

ValueObjectSP GenericOptionalFrontend::GetChildAtIndex(size_t _idx) {
 
   if (m_stdlib == StdLib::LibCxx)
     // __val_ contains the underlying value of an optional if it has one.
     // Currently because it is part of an anonymous union
     // GetChildMemberWithName() does not peer through and find it unless we are
     // at the parent itself. We can obtain the parent through __engaged_.
     val_sp = m_backend.GetChildMemberWithName("__engaged_")
                  ->GetParent()
-                 ->GetChildAtIndex(0, true)
+                 ->GetChildAtIndex(0)
                  ->GetChildMemberWithName("__val_");
   else if (m_stdlib == StdLib::LibStdcpp) {
     val_sp = m_backend.GetChildMemberWithName("_M_payload")
                  ->GetChildMemberWithName("_M_payload");
 
     // In some implementations, _M_value contains the underlying value of an
     // optional, and in other versions, it's in the payload member.
     ValueObjectSP candidate = val_sp->GetChildMemberWithName("_M_value");

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

lldb::ValueObjectSP lldb_private::formatters::GetChildMemberWithName(
   }
   return {};
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::GetFirstValueOfLibCXXCompressedPair(
     ValueObject &pair) {
   ValueObjectSP value;
-  ValueObjectSP first_child = pair.GetChildAtIndex(0, true);
+  ValueObjectSP first_child = pair.GetChildAtIndex(0);
   if (first_child)
     value = first_child->GetChildMemberWithName("__value_");
   if (!value) {
     // pre-r300140 member name
     value = pair.GetChildMemberWithName("__first_");
   }
   return value;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::GetSecondValueOfLibCXXCompressedPair(
     ValueObject &pair) {
   ValueObjectSP value;
   if (pair.GetNumChildren() > 1) {
-    ValueObjectSP second_child = pair.GetChildAtIndex(1, true);
+    ValueObjectSP second_child = pair.GetChildAtIndex(1);
     if (second_child) {
       value = second_child->GetChildMemberWithName("__value_");
     }
   }
   if (!value) {
     // pre-r300140 member name
     value = pair.GetChildMemberWithName("__second_");
   }
if (m_pair_ptr) {
         if (error.Fail())
           return false;
         DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(),
                                 process_sp->GetAddressByteSize());
         auto pair_sp = CreateValueObjectFromData(
             "pair", extractor, valobj_sp->GetExecutionContextRef(),
             tree_node_type);
         if (pair_sp)
-          m_pair_sp = pair_sp->GetChildAtIndex(4, true);
+          m_pair_sp = pair_sp->GetChildAtIndex(4);
       }
     }
   }
 
   return false;
 }
 
 size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
     CalculateNumChildren() {
   return 2;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetChildAtIndex(
     size_t idx) {
   if (m_pair_ptr)
-    return m_pair_ptr->GetChildAtIndex(idx, true);
+    return m_pair_ptr->GetChildAtIndex(idx);
   if (m_pair_sp)
-    return m_pair_sp->GetChildAtIndex(idx, true);
+    return m_pair_sp->GetChildAtIndex(idx);
   return lldb::ValueObjectSP();
 }
 
 bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 
process_sp->ReadMemory(addr, buffer_sp->GetBytes(),
                            buffer_sp->GetByteSize(), error);
     if (error.Fail())
       return false;
     DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(),
                             process_sp->GetAddressByteSize());
     auto pair_sp = CreateValueObjectFromData(
         "pair", extractor, valobj_sp->GetExecutionContextRef(), tree_node_type);
     if (pair_sp)
-      m_pair_sp = pair_sp->GetChildAtIndex(2, true);
+      m_pair_sp = pair_sp->GetChildAtIndex(2);
   }
 
   return false;
 }
 
 size_t lldb_private::formatters::LibCxxUnorderedMapIteratorSyntheticFrontEnd::
     CalculateNumChildren() {
   return 2;
 }
 
 lldb::ValueObjectSP lldb_private::formatters::
     LibCxxUnorderedMapIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
   if (m_pair_sp)
-    return m_pair_sp->GetChildAtIndex(idx, true);
+    return m_pair_sp->GetChildAtIndex(idx);
   return lldb::ValueObjectSP();
 }
 
 bool lldb_private::formatters::LibCxxUnorderedMapIteratorSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 

 static std::optional<std::pair<uint64_t, ValueObjectSP>>
 ExtractLibcxxStringInfo(ValueObject &valobj) {
   ValueObjectSP valobj_r_sp = valobj.GetChildMemberWithName("__r_");
   if (!valobj_r_sp || !valobj_r_sp->GetError().Success())
     return {};
 
   // __r_ is a compressed_pair of the actual data and the allocator. The data we
   // want is in the first base class.
-  ValueObjectSP valobj_r_base_sp =
-      valobj_r_sp->GetChildAtIndex(0, /*can_create=*/true);
+  ValueObjectSP valobj_r_base_sp = valobj_r_sp->GetChildAtIndex(0);
   if (!valobj_r_base_sp)
     return {};
 
   ValueObjectSP valobj_rep_sp =
       valobj_r_base_sp->GetChildMemberWithName("__value_");
   if (!valobj_rep_sp)
     return {};
 

lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

ValueObjectSP ForwardListFrontEnd::GetChildAtIndex(size_t idx) {
 
   if (HasLoop(idx + 1))
     return nullptr;
 
   ValueObjectSP current_sp = GetItem(idx);
   if (!current_sp)
     return nullptr;
 
-  current_sp = current_sp->GetChildAtIndex(1, true); // get the __value_ child
+  current_sp = current_sp->GetChildAtIndex(1); // get the __value_ child
   if (!current_sp)
     return nullptr;
 
   // we need to copy current_sp into a new object otherwise we will end up with
   // all items named __value_
   DataExtractor data;
   Status error;
   current_sp->GetData(data, error);
lldb::ValueObjectSP ListFrontEnd::GetChildAtIndex(size_t idx) {
 
   if (HasLoop(idx + 1))
     return lldb::ValueObjectSP();
 
   ValueObjectSP current_sp = GetItem(idx);
   if (!current_sp)
     return lldb::ValueObjectSP();
 
-  current_sp = current_sp->GetChildAtIndex(1, true); // get the __value_ child
+  current_sp = current_sp->GetChildAtIndex(1); // get the __value_ child
   if (!current_sp)
     return lldb::ValueObjectSP();
 
   if (current_sp->GetName() == g_next) {
     ProcessSP process_sp(current_sp->GetProcessSP());
     if (!process_sp)
       return lldb::ValueObjectSP();
 

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
 
   switch (m_item->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
     m_item = m_item->GetChildMemberWithName("__first_");
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
-    ValueObjectSP first_elem_parent = m_item->GetChildAtIndex(0, true);
+    ValueObjectSP first_elem_parent = m_item->GetChildAtIndex(0);
     m_item = first_elem_parent->GetChildMemberWithName("__value_");
     break;
   }
   default:
     return false;
   }
 
   if (!m_item)
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
   // we need to copy current_sp into a new object otherwise we will end up with
   // all items named __value_
   StreamString name;
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   auto potential_child_sp = iterated_sp->Clone(ConstString(name.GetString()));
   if (potential_child_sp) {
     switch (potential_child_sp->GetNumChildren()) {
     case 1: {
-      auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
+      auto child0_sp = potential_child_sp->GetChildAtIndex(0);
       if (child0_sp &&
           (child0_sp->GetName() == g_cc_ || child0_sp->GetName() == g_cc))
         potential_child_sp = child0_sp->Clone(ConstString(name.GetString()));
       break;
     }
     case 2: {
-      auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
-      auto child1_sp = potential_child_sp->GetChildAtIndex(1, true);
+      auto child0_sp = potential_child_sp->GetChildAtIndex(0);
+      auto child1_sp = potential_child_sp->GetChildAtIndex(1);
       if (child0_sp &&
           (child0_sp->GetName() == g_cc_ || child0_sp->GetName() == g_cc) &&
           child1_sp && child1_sp->GetName() == g_nc)
         potential_child_sp = child0_sp->Clone(ConstString(name.GetString()));
       break;
     }
     }
   }

lldb/source/Plugins/Language/CPlusPlus/LibCxxQueue.cpp

public:
   bool MightHaveChildren() override { return true; }
   bool Update() override;
 
   size_t CalculateNumChildren() override {
     return m_container_sp ? m_container_sp->GetNumChildren() : 0;
   }
 
   ValueObjectSP GetChildAtIndex(size_t idx) override {
-    return m_container_sp ? m_container_sp->GetChildAtIndex(idx, true)
+    return m_container_sp ? m_container_sp->GetChildAtIndex(idx)
                           : nullptr;
   }
 
 private:
   // The lifetime of a ValueObject and all its derivative ValueObjects
   // (children, clones, etc.) is managed by a ClusterManager. These
   // objects are only destroyed when every shared pointer to any of them
   // is destroyed, so we must not store a shared pointer to any ValueObject

lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp

if (!m_base)
     return ValueObjectSP();
   if (m_elements[idx])
     return m_elements[idx]->GetSP();
 
   CompilerType holder_type =
       m_base->GetCompilerType().GetDirectBaseClassAtIndex(idx, nullptr);
   if (!holder_type)
     return ValueObjectSP();
-  ValueObjectSP holder_sp = m_base->GetChildAtIndex(idx, true);
+  ValueObjectSP holder_sp = m_base->GetChildAtIndex(idx);
   if (!holder_sp)
     return ValueObjectSP();
 
-  ValueObjectSP elem_sp = holder_sp->GetChildAtIndex(0, true);
+  ValueObjectSP elem_sp = holder_sp->GetChildAtIndex(0);
   if (elem_sp)
     m_elements[idx] =
         elem_sp->Clone(ConstString(llvm::formatv("[{0}]", idx).str())).get();
 
   if (m_elements[idx])
     return m_elements[idx]->GetSP();
   return ValueObjectSP();
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxTupleFrontEndCreator(CXXSyntheticChildren *,
                                        lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new TupleFrontEnd(*valobj_sp);
   return nullptr;
 }

lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

if (!hash_sp || !value_sp) {
         switch (p1_sp->GetCompilerType().GetNumDirectBaseClasses()) {
         case 1:
           // Assume a pre llvm r300140 __compressed_pair implementation:
           first_sp = p1_sp->GetChildMemberWithName("__first_");
           break;
         case 2: {
           // Assume a post llvm r300140 __compressed_pair implementation:
           ValueObjectSP first_elem_parent_sp =
-            p1_sp->GetChildAtIndex(0, true);
+            p1_sp->GetChildAtIndex(0);
           first_sp = p1_sp->GetChildMemberWithName("__value_");
           break;
         }
         default:
           return nullptr;
         }
 
         if (!first_sp)
bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
   switch (p2_sp->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
     num_elements_sp = p2_sp->GetChildMemberWithName("__first_");
     next_path.append({"__p1_", "__first_", "__next_"});
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
-    ValueObjectSP first_elem_parent = p2_sp->GetChildAtIndex(0, true);
+    ValueObjectSP first_elem_parent = p2_sp->GetChildAtIndex(0);
     num_elements_sp = first_elem_parent->GetChildMemberWithName("__value_");
     next_path.append({"__p1_", "__value_", "__next_"});
     break;
   }
   default:
     return false;
   }
 

lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
     data_type_finder_sp =
         data_type_finder_sp->GetChildMemberWithName("__first_");
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent_sp =
-      data_type_finder_sp->GetChildAtIndex(0, true);
+      data_type_finder_sp->GetChildAtIndex(0);
     data_type_finder_sp =
         first_elem_parent_sp->GetChildMemberWithName("__value_");
     break;
   }
   default:
     return false;
   }
 

lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

 
 lldb::ValueObjectSP
 LibstdcppMapIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
   if (m_pair_address != 0 && m_pair_type) {
     if (!m_pair_sp)
       m_pair_sp = CreateValueObjectFromAddress("pair", m_pair_address,
                                                m_exe_ctx_ref, m_pair_type);
     if (m_pair_sp)
-      return m_pair_sp->GetChildAtIndex(idx, true);
+      return m_pair_sp->GetChildAtIndex(idx);
   }
   return lldb::ValueObjectSP();
 }
 
 bool LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
 
 size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
     ConstString name) {

lldb/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp

bool LibStdcppTupleSyntheticFrontEnd::Update() {
 
   ValueObjectSP next_child_sp = valobj_backend_sp->GetNonSyntheticValue();
   while (next_child_sp != nullptr) {
     ValueObjectSP current_child = next_child_sp;
     next_child_sp = nullptr;
 
     size_t child_count = current_child->GetNumChildren();
     for (size_t i = 0; i < child_count; ++i) {
-      ValueObjectSP child_sp = current_child->GetChildAtIndex(i, true);
+      ValueObjectSP child_sp = current_child->GetChildAtIndex(i);
       llvm::StringRef name_str = child_sp->GetName().GetStringRef();
       if (name_str.startswith("std::_Tuple_impl<")) {
         next_child_sp = child_sp;
       } else if (name_str.startswith("std::_Head_base<")) {
         ValueObjectSP value_sp =
             child_sp->GetChildMemberWithName("_M_head_impl");
         if (value_sp) {
           StreamString name;

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

bool lldb_private::formatters::ObjCBOOLSummaryProvider(
   ValueObjectSP real_guy_sp = valobj.GetSP();
 
   if (type_info & eTypeIsPointer) {
     Status err;
     real_guy_sp = valobj.Dereference(err);
     if (err.Fail() || !real_guy_sp)
       return false;
   } else if (type_info & eTypeIsReference) {
-    real_guy_sp = valobj.GetChildAtIndex(0, true);
+    real_guy_sp = valobj.GetChildAtIndex(0);
     if (!real_guy_sp)
       return false;
   }
   int8_t value = (real_guy_sp->GetValueAsSigned(0) & 0xFF);
   switch (value) {
   case 0:
     stream.Printf("NO");
     break;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

auto objc_object_from_address = [&exception_sp, &objc_id](uint64_t addr,
     value.SetCompilerType(objc_id);
     auto object = ValueObjectConstResult::Create(
         exception_sp->GetTargetSP().get(), value, ConstString(name));
     object = object->GetDynamicValue(eDynamicDontRunTarget);
     return object;
   };
 
   for (size_t idx = 0; idx < reserved_dict->GetNumChildren(); idx++) {
-    ValueObjectSP dict_entry = reserved_dict->GetChildAtIndex(idx, true);
+    ValueObjectSP dict_entry = reserved_dict->GetChildAtIndex(idx);
 
     DataExtractor data;
     data.SetAddressByteSize(dict_entry->GetProcessSP()->GetAddressByteSize());
     Status error;
     dict_entry->GetData(data, error);
     if (error.Fail()) return ThreadSP();
 
     lldb::offset_t data_offset = 0;

lldb/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

static void CreateHistoryThreadFromValueObject(ProcessSP process_sp,
   ValueObjectSP trace_sp =
       return_value_sp->GetValueForExpressionPath(trace_path.c_str());
 
   if (!trace_sp)
     return;
 
   std::vector<lldb::addr_t> pcs;
   for (int i = 0; i < count; i++) {
-    addr_t pc = trace_sp->GetChildAtIndex(i, true)->GetValueAsUnsigned(0);
+    addr_t pc = trace_sp->GetChildAtIndex(i)->GetValueAsUnsigned(0);
     if (pc == 0 || pc == 1 || pc == LLDB_INVALID_ADDRESS)
       continue;
     pcs.push_back(pc);
   }
 
   // The ASAN runtime already massages the return addresses into call
   // addresses, we don't want LLDB's unwinder to try to locate the previous
   // instruction again as this might lead to us reporting a different line.

lldb/source/Target/StackFrame.cpp

case '[': {
           deref = false;
         } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
                    deref) {
           // what we have is *arr[low]. the most similar C++ syntax is to get
           // arr[0] (an operation that is equivalent to deref-ing arr) and
           // extract bit low out of it. reading array item low would be done by
           // saying arr[low], without a deref * sign
           Status error;
-          ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
+          ValueObjectSP temp(valobj_sp->GetChildAtIndex(0));
           if (error.Fail()) {
             valobj_sp->GetExpressionPath(var_expr_path_strm);
             error.SetErrorStringWithFormat(
                 "could not get item 0 for \"(%s) %s\"",
                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
                 var_expr_path_strm.GetData());
             return ValueObjectSP();
           }
case '[': {
                 synthetic
                     ->GetNumChildren() /* synthetic does not have that many values */) {
               valobj_sp->GetExpressionPath(var_expr_path_strm);
               error.SetErrorStringWithFormat(
                   "array index %ld is not valid for \"(%s) %s\"", child_index,
                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
                   var_expr_path_strm.GetData());
             } else {
-              child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
+              child_valobj_sp = synthetic->GetChildAtIndex(child_index);
               if (!child_valobj_sp) {
                 valobj_sp->GetExpressionPath(var_expr_path_strm);
                 error.SetErrorStringWithFormat(
                     "array index %ld is not valid for \"(%s) %s\"", child_index,
                     valobj_sp->GetTypeName().AsCString("<invalid type>"),
                     var_expr_path_strm.GetData());
               }
             }
case '[': {
                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
                   var_expr_path_strm.GetData());
             }
           }
         } else if (valobj_sp->GetCompilerType().IsArrayType(
                        nullptr, nullptr, &is_incomplete_array)) {
           // Pass false to dynamic_value here so we can tell the difference
           // between no dynamic value and no member of this type...
-          child_valobj_sp = valobj_sp->GetChildAtIndex(child_index, true);
+          child_valobj_sp = valobj_sp->GetChildAtIndex(child_index);
           if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
             child_valobj_sp =
                 valobj_sp->GetSyntheticArrayMember(child_index, true);
 
           if (!child_valobj_sp) {
             valobj_sp->GetExpressionPath(var_expr_path_strm);
             error.SetErrorStringWithFormat(
                 "array index %ld is not valid for \"(%s) %s\"", child_index,
case '[': {
               synthetic
                   ->GetNumChildren() /* synthetic does not have that many values */) {
             valobj_sp->GetExpressionPath(var_expr_path_strm);
             error.SetErrorStringWithFormat(
                 "array index %ld is not valid for \"(%s) %s\"", child_index,
                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
                 var_expr_path_strm.GetData());
           } else {
-            child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
+            child_valobj_sp = synthetic->GetChildAtIndex(child_index);
             if (!child_valobj_sp) {
               valobj_sp->GetExpressionPath(var_expr_path_strm);
               error.SetErrorStringWithFormat(
                   "array index %ld is not valid for \"(%s) %s\"", child_index,
                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
                   var_expr_path_strm.GetData());
             }
           }
case '[': {
         valobj_sp = temp;
         deref = false;
       } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
         // what we have is *arr[low-high]. the most similar C++ syntax is to
         // get arr[0] (an operation that is equivalent to deref-ing arr) and
         // extract bits low thru high out of it. reading array items low thru
         // high would be done by saying arr[low-high], without a deref * sign
         Status error;
-        ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
+        ValueObjectSP temp(valobj_sp->GetChildAtIndex(0));
         if (error.Fail()) {
           valobj_sp->GetExpressionPath(var_expr_path_strm);
           error.SetErrorStringWithFormat(
               "could not get item 0 for \"(%s) %s\"",
               valobj_sp->GetTypeName().AsCString("<invalid type>"),
               var_expr_path_strm.GetData());
           return ValueObjectSP();
         }
if (offset < 0 || uint64_t(offset) >= parent->GetByteSize()) {
     return ValueObjectSP();
   }
 
   if (parent->IsPointerOrReferenceType()) {
     return parent;
   }
 
   for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
-    const bool can_create = true;
-    ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
+    ValueObjectSP child_sp = parent->GetChildAtIndex(ci);
 
     if (!child_sp) {
       return ValueObjectSP();
     }
 
     int64_t child_offset = child_sp->GetByteOffset();
     int64_t child_size = child_sp->GetByteSize().value_or(0);