[lldb] Take StringRef name in GetChildMemberWithName (NFC)

[kastiglione]

Summary

GetChildMemberWithName does not need a ConstString. This change makes the function
take a StringRef instead, which alleviates the need for callers to construct a
ConstString. I don't expect this change to improve performance, only ergonomics.

This is in support of Alex's effort to replace ConstString where appropriate.

There are related ValueObject functions that can also be changed, if this is accepted.

[bulbazord]

After reading though the code and thinking about it, I believe this change is appropriate. It may or may not have a measurable impact on performance, but my bet is that it doesn't make it worse. I suppose you could stress test the C++ formatters if you really wanted to know though. Either way, thank you for doing this work!

We should probably change CompilerType::GetIndexOfChildMemberWithName to take a StringRef instead of a const char * as a follow-up. You're having to call str() and then getting the const char * out of that to correctly call the function which is the right thing to do but is also a little wasteful.

[kastiglione]

In D151615#4378130, @bulbazord wrote:

It may or may not have a measurable impact on performance, but my bet is that it doesn't make it worse.

yes the reason I wanted this change is for ergonomics, I was annoyed that it required a ConstString when internally it needs only a null terminated string. Eliminating these ConstStrings won't have perf savings, but it won't have a perf cost either.

I suppose you could stress test the C++ formatters if you really wanted to know though. Either way, thank you for doing this work!

Do you have something in mind? I figured the test suite was enough. Do you mean stress for perf, or for ensuring this change has no behavior regressions?

We should probably change CompilerType::GetIndexOfChildMemberWithName to take a StringRef instead of a const char * as a follow-up.

I made the same observation. I figured this change was big enough and was also a single semantic change, so I didn't scope it out any further.

[bulbazord]

In D151615#4378441, @kastiglione wrote:

Do you have something in mind? I figured the test suite was enough. Do you mean stress for perf, or for ensuring this change has no behavior regressions?

I meant stress test for perf. Behavior-wise I think the test suite should catch anything major. I'd be surprised if this changed behavior since you're passing the same data around but in a different form.
I don't have anything in mind however. Should be fine without it.

I made the same observation. I figured this change was big enough and was also a single semantic change, so I didn't scope it out any further.

Sounds good.

lldb/include/lldb/Core/ValueObject.h

public:
   // this will always create the children if necessary
   lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<ConstString> names,
                                          ConstString *name_of_error = nullptr);
 
   lldb::ValueObjectSP
   GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names,
                      ConstString *name_of_error = nullptr);
 
-  virtual lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
+  virtual lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                                      bool can_create);
 
   virtual size_t GetIndexOfChildWithName(ConstString name);
 
   size_t GetNumChildren(uint32_t max = UINT32_MAX);
 
   const Value &GetValue() const { return m_value; }
 

lldb/include/lldb/Core/ValueObjectRegister.h

public:
 
   ConstString GetQualifiedTypeName() override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
                                   int32_t synthetic_index) override;
 
-  lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
+  lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create) override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 protected:
   bool UpdateValue() override;
 
   CompilerType GetCompilerTypeImpl() override;

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

public:
   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 GetChildMemberWithName(ConstString name,
+  lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create) override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
   lldb::ValueObjectSP
   GetDynamicValue(lldb::DynamicValueType valueType) override;
 
   bool IsInScope() override;

lldb/source/API/SBValue.cpp

 }
 
 SBValue
 SBValue::GetChildMemberWithName(const char *name,
                                 lldb::DynamicValueType use_dynamic_value) {
   LLDB_INSTRUMENT_VA(this, name, use_dynamic_value);
 
   lldb::ValueObjectSP child_sp;
-  const ConstString str_name(name);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
-    child_sp = value_sp->GetChildMemberWithName(str_name, true);
+    child_sp = value_sp->GetChildMemberWithName(name, true);
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
 
   return sb_value;
 }
 

lldb/source/Core/ValueObject.cpp

 }
 
 size_t ValueObject::GetIndexOfChildWithName(ConstString name) {
   bool omit_empty_base_classes = true;
   return GetCompilerType().GetIndexOfChildWithName(name.GetCString(),
                                                    omit_empty_base_classes);
 }
 
-ValueObjectSP ValueObject::GetChildMemberWithName(ConstString name,
+ValueObjectSP ValueObject::GetChildMemberWithName(llvm::StringRef name,
                                                   bool can_create) {
   // We may need to update our value if we are dynamic.
   if (IsPossibleDynamicType())
     UpdateValueIfNeeded(false);
 
   // When getting a child by name, it could be buried inside some base classes
   // (which really aren't part of the expression path), so we need a vector of
   // indexes that can get us down to the correct child.
   std::vector<uint32_t> child_indexes;
   bool omit_empty_base_classes = true;
 
   if (!GetCompilerType().IsValid())
     return ValueObjectSP();
 
   const size_t num_child_indexes =
       GetCompilerType().GetIndexOfChildMemberWithName(
-          name.GetCString(), omit_empty_base_classes, child_indexes);
+          name.str().data(), omit_empty_base_classes, child_indexes);
   if (num_child_indexes == 0)
     return nullptr;
 
   ValueObjectSP child_sp = GetSP();
   for (uint32_t idx : child_indexes)
     if (child_sp)
       child_sp = child_sp->GetChildAtIndex(idx, can_create);
   return child_sp;
if (!m_deref_valobj) {
               child_byte_offset, child_bitfield_bit_size,
               child_bitfield_bit_offset, child_is_base_class,
               child_is_deref_of_parent, eAddressTypeInvalid, language_flags);
         }
       }
     }
 
   } else if (HasSyntheticValue()) {
-    m_deref_valobj =
-        GetSyntheticValue()
-            ->GetChildMemberWithName(ConstString("$$dereference$$"), true)
+    m_deref_valobj = GetSyntheticValue()
+                         ->GetChildMemberWithName("$$dereference$$", true)
                          .get();
   } else if (IsSynthetic()) {
-    m_deref_valobj =
-        GetChildMemberWithName(ConstString("$$dereference$$"), true).get();
+    m_deref_valobj = GetChildMemberWithName("$$dereference$$", true).get();
   }
 
   if (m_deref_valobj) {
     error.Clear();
     return m_deref_valobj->GetSP();
   } else {
     StreamString strm;
     GetExpressionPath(strm);

lldb/source/Core/ValueObjectRegister.cpp

if (idx < num_children)
       valobj = new ValueObjectRegister(
           *this, m_reg_ctx_sp,
           m_reg_ctx_sp->GetRegisterInfoAtIndex(m_reg_set->registers[idx]));
   }
   return valobj;
 }
 
 lldb::ValueObjectSP
-ValueObjectRegisterSet::GetChildMemberWithName(ConstString name,
+ValueObjectRegisterSet::GetChildMemberWithName(llvm::StringRef name,
                                                bool can_create) {
   ValueObject *valobj = nullptr;
   if (m_reg_ctx_sp && m_reg_set) {
-    const RegisterInfo *reg_info =
-        m_reg_ctx_sp->GetRegisterInfoByName(name.GetStringRef());
+    const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName(name);
     if (reg_info != nullptr)
       valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, reg_info);
   }
   if (valobj)
     return valobj->GetSP();
   else
     return ValueObjectSP();
 }

lldb/source/Core/ValueObjectSyntheticFilter.cpp

LLDB_LOGF(log,
               "index %zu cached as %p",
               GetName().AsCString(), idx, static_cast<void *>(valobj));
 
     return valobj->GetSP();
   }
 }
 
 lldb::ValueObjectSP
-ValueObjectSynthetic::GetChildMemberWithName(ConstString name,
+ValueObjectSynthetic::GetChildMemberWithName(llvm::StringRef name,
                                              bool can_create) {
   UpdateValueIfNeeded();
 
-  uint32_t index = GetIndexOfChildWithName(name);
+  uint32_t index = GetIndexOfChildWithName(ConstString(name));
 
   if (index == UINT32_MAX)
     return lldb::ValueObjectSP();
 
   return GetChildAtIndex(index, can_create);
 }
 
 size_t ValueObjectSynthetic::GetIndexOfChildWithName(ConstString name) {

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

 /// members are the lambda captures. If we capture a 'this' pointer,
 /// the artifical class will contain a member variable named 'this'.
 /// The function returns a ValueObject for the captured 'this' if such
 /// member exists. If no 'this' was captured, return a nullptr.
 lldb::ValueObjectSP GetCapturedThisValueObject(StackFrame *frame) {
   assert(frame);
 
   if (auto thisValSP = frame->FindVariable(ConstString("this")))
-    if (auto thisThisValSP =
-            thisValSP->GetChildMemberWithName(ConstString("this"), true))
+    if (auto thisThisValSP = thisValSP->GetChildMemberWithName("this", true))
       return thisThisValSP;
 
   return nullptr;
 }
 } // namespace
 
 ClangExpressionDeclMap::ClangExpressionDeclMap(
     bool keep_result_in_memory,

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

 #include "lldb/Utility/ConstString.h"
 
 namespace lldb_private {
 namespace ClangExpressionUtil {
 lldb::ValueObjectSP GetLambdaValueObject(StackFrame *frame) {
   assert(frame);
 
   if (auto this_val_sp = frame->FindVariable(ConstString("this")))
-    if (this_val_sp->GetChildMemberWithName(ConstString("this"), true))
+    if (this_val_sp->GetChildMemberWithName("this", true))
       return this_val_sp;
 
   return nullptr;
 }
 } // namespace ClangExpressionUtil
 } // namespace lldb_private

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

 lldb::addr_t ClangUserExpression::GetCppObjectPointer(
     lldb::StackFrameSP frame_sp, ConstString &object_name, Status &err) {
   auto valobj_sp =
       GetObjectPointerValueObject(std::move(frame_sp), object_name, err);
 
   // We're inside a C++ class method. This could potentially be an unnamed
   // lambda structure. If the lambda captured a "this", that should be
   // the object pointer.
-  if (auto thisChildSP =
-          valobj_sp->GetChildMemberWithName(ConstString("this"), true)) {
+  if (auto thisChildSP = valobj_sp->GetChildMemberWithName("this", true)) {
     valobj_sp = thisChildSP;
   }
 
   if (!err.Success() || !valobj_sp.get())
     return LLDB_INVALID_ADDRESS;
 
   lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 

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

if (auto target_sp = m_backend.GetTargetSP()) {
     Update();
   }
 }
 
 bool GenericOptionalFrontend::Update() {
   ValueObjectSP engaged_sp;
 
   if (m_stdlib == StdLib::LibCxx)
-    engaged_sp =
-        m_backend.GetChildMemberWithName(ConstString("__engaged_"), true);
+    engaged_sp = m_backend.GetChildMemberWithName("__engaged_", true);
   else if (m_stdlib == StdLib::LibStdcpp)
-    engaged_sp =
-        m_backend.GetChildMemberWithName(ConstString("_M_payload"), true)
-            ->GetChildMemberWithName(ConstString("_M_engaged"), true);
+    engaged_sp = m_backend.GetChildMemberWithName("_M_payload", true)
+                     ->GetChildMemberWithName("_M_engaged", true);
 
   if (!engaged_sp)
     return false;
 
   // _M_engaged/__engaged is a bool flag and is true if the optional contains a
   // value. Converting it to unsigned gives us a size of 1 if it contains a
   // value and 0 if not.
   m_has_value = engaged_sp->GetValueAsUnsigned(0) != 0;
 
   return false;
 }
 
 ValueObjectSP GenericOptionalFrontend::GetChildAtIndex(size_t _idx) {
   if (!m_has_value)
     return ValueObjectSP();
 
   ValueObjectSP val_sp;
 
   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(ConstString("__engaged_"), true)
+    val_sp = m_backend.GetChildMemberWithName("__engaged_", true)
                  ->GetParent()
                  ->GetChildAtIndex(0, true)
-                 ->GetChildMemberWithName(ConstString("__val_"), true);
+                 ->GetChildMemberWithName("__val_", true);
   else if (m_stdlib == StdLib::LibStdcpp) {
-    val_sp = m_backend.GetChildMemberWithName(ConstString("_M_payload"), true)
-                 ->GetChildMemberWithName(ConstString("_M_payload"), true);
+    val_sp = m_backend.GetChildMemberWithName("_M_payload", true)
+                 ->GetChildMemberWithName("_M_payload", true);
 
     // 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(ConstString("_M_value"), true);
+    ValueObjectSP candidate = val_sp->GetChildMemberWithName("_M_value", true);
     if (candidate)
       val_sp = candidate;
   }
 
   if (!val_sp)
     return ValueObjectSP();
 
   CompilerType holder_type = val_sp->GetCompilerType();

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

 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::GetFirstValueOfLibCXXCompressedPair(
     ValueObject &pair) {
   ValueObjectSP value;
   ValueObjectSP first_child = pair.GetChildAtIndex(0, true);
   if (first_child)
-    value = first_child->GetChildMemberWithName(ConstString("__value_"), true);
+    value = first_child->GetChildMemberWithName("__value_", true);
   if (!value) {
     // pre-r300140 member name
-    value = pair.GetChildMemberWithName(ConstString("__first_"), true);
+    value = pair.GetChildMemberWithName("__first_", true);
   }
   return value;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::GetSecondValueOfLibCXXCompressedPair(
     ValueObject &pair) {
   ValueObjectSP value;
   if (pair.GetNumChildren() > 1) {
     ValueObjectSP second_child = pair.GetChildAtIndex(1, true);
     if (second_child) {
-      value =
-          second_child->GetChildMemberWithName(ConstString("__value_"), true);
+      value = second_child->GetChildMemberWithName("__value_", true);
     }
   }
   if (!value) {
     // pre-r300140 member name
-    value = pair.GetChildMemberWithName(ConstString("__second_"), true);
+    value = pair.GetChildMemberWithName("__second_", true);
   }
   return value;
 }
 
 bool lldb_private::formatters::LibcxxOptionalSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
   // An optional either contains a value or not, the member __engaged_ is
   // a bool flag, it is true if the optional has a value and false otherwise.
   ValueObjectSP engaged_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__engaged_"), true));
+      valobj_sp->GetChildMemberWithName("__engaged_", true));
 
   if (!engaged_sp)
     return false;
 
   llvm::StringRef engaged_as_cstring(
       engaged_sp->GetValueAsUnsigned(0) == 1 ? "true" : "false");
 
   stream.Printf(" Has Value=%s ", engaged_as_cstring.data());
bool lldb_private::formatters::LibcxxFunctionSummaryProvider(
   return true;
 }
 
 bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
-  ValueObjectSP ptr_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
   ValueObjectSP count_sp(valobj_sp->GetChildAtNamePath(
       {ConstString("__cntrl_"), ConstString("__shared_owners_")}));
   ValueObjectSP weakcount_sp(valobj_sp->GetChildAtNamePath(
       {ConstString("__cntrl_"), ConstString("__shared_weak_owners_")}));
 
   if (!ptr_sp)
     return false;
 

 }
 
 bool lldb_private::formatters::LibcxxUniquePointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
   if (!ptr_sp)
     return false;
 
   ptr_sp = GetFirstValueOfLibCXXCompressedPair(*ptr_sp);
   if (!ptr_sp)
     return false;
 
   if (ptr_sp->GetValueAsUnsigned(0) == 0) {
bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() {
   TargetSP target_sp(valobj_sp->GetTargetSP());
 
   if (!target_sp)
     return false;
 
   if (!valobj_sp)
     return false;
 
-  static ConstString g_i_("__i_");
-
   // this must be a ValueObject* because it is a child of the ValueObject we
   // are producing children for it if were a ValueObjectSP, we would end up
   // with a loop (iterator -> synthetic -> child -> parent == iterator) and
   // that would in turn leak memory by never allowing the ValueObjects to die
   // and free their memory
   m_pair_ptr = valobj_sp
                    ->GetValueForExpressionPath(
                        ".__i_.__ptr_->__value_", nullptr, nullptr,
m_pair_ptr = valobj_sp
                          ValueObject::GetValueForExpressionPathOptions()
                              .DontCheckDotVsArrowSyntax()
                              .SetSyntheticChildrenTraversal(
                                  ValueObject::GetValueForExpressionPathOptions::
                                      SyntheticChildrenTraversal::None),
                          nullptr)
                      .get();
     if (m_pair_ptr) {
-      auto __i_(valobj_sp->GetChildMemberWithName(g_i_, true));
+      auto __i_(valobj_sp->GetChildMemberWithName("__i_", true));
       if (!__i_) {
         m_pair_ptr = nullptr;
         return false;
       }
       CompilerType pair_type(
           __i_->GetCompilerType().GetTypeTemplateArgument(0));
       std::string name;
       uint64_t bit_offset_ptr;
bool lldb_private::formatters::LibCxxUnorderedMapIteratorSyntheticFrontEnd::
   // and free their memory.
   m_iter_ptr =
       valobj_sp
           ->GetValueForExpressionPath(".__i_.__node_", nullptr, nullptr,
                                       exprPathOptions, nullptr)
           .get();
 
   if (m_iter_ptr) {
-    auto iter_child(
-        valobj_sp->GetChildMemberWithName(ConstString("__i_"), true));
+    auto iter_child(valobj_sp->GetChildMemberWithName("__i_", true));
     if (!iter_child) {
       m_iter_ptr = nullptr;
       return false;
     }
 
     CompilerType node_type(iter_child->GetCompilerType()
                                .GetTypeTemplateArgument(0)
                                .GetPointeeType());
lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetChildAtIndex(
   if (!m_cntrl)
     return lldb::ValueObjectSP();
 
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return lldb::ValueObjectSP();
 
   if (idx == 0)
-    return valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true);
+    return valobj_sp->GetChildMemberWithName("__ptr_", true);
 
   if (idx == 1) {
-    if (auto ptr_sp =
-            valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true)) {
+    if (auto ptr_sp = valobj_sp->GetChildMemberWithName("__ptr_", true)) {
       Status status;
       auto value_sp = ptr_sp->Dereference(status);
       if (status.Success()) {
         auto value_type_sp =
             valobj_sp->GetCompilerType().GetTypeTemplateArgument(0);
         return value_sp->Cast(value_type_sp);
       }
     }
bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() {
   if (!valobj_sp)
     return false;
 
   TargetSP target_sp(valobj_sp->GetTargetSP());
   if (!target_sp)
     return false;
 
   lldb::ValueObjectSP cntrl_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__cntrl_"), true));
+      valobj_sp->GetChildMemberWithName("__cntrl_", true));
 
   m_cntrl = cntrl_sp.get(); // need to store the raw pointer to avoid a circular
                             // dependency
   return false;
 }
 
 bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::
     MightHaveChildren() {
lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::GetChildAtIndex(
   return lldb::ValueObjectSP();
 }
 
 bool lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::Update() {
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
   if (!ptr_sp)
     return false;
 
   // Retrieve the actual pointer and the deleter, and clone them to give them
   // user-friendly names.
   ValueObjectSP value_pointer_sp = GetFirstValueOfLibCXXCompressedPair(*ptr_sp);
   if (value_pointer_sp)
     m_value_ptr_sp = value_pointer_sp->Clone(ConstString("pointer"));

 }
 
 /// Determine the size in bytes of \p valobj (a libc++ std::string object) and
 /// extract its data payload. Return the size + payload pair.
 // TODO: Support big-endian architectures.
 static std::optional<std::pair<uint64_t, ValueObjectSP>>
 ExtractLibcxxStringInfo(ValueObject &valobj) {
   ValueObjectSP valobj_r_sp =
-      valobj.GetChildMemberWithName(ConstString("__r_"), /*can_create=*/true);
+      valobj.GetChildMemberWithName("__r_", /*can_create=*/true);
   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);
   if (!valobj_r_base_sp)
     return {};
 
-  ValueObjectSP valobj_rep_sp = valobj_r_base_sp->GetChildMemberWithName(
-      ConstString("__value_"), /*can_create=*/true);
+  ValueObjectSP valobj_rep_sp =
+      valobj_r_base_sp->GetChildMemberWithName("__value_", /*can_create=*/true);
   if (!valobj_rep_sp)
     return {};
 
-  ValueObjectSP l = valobj_rep_sp->GetChildMemberWithName(ConstString("__l"),
+  ValueObjectSP l = valobj_rep_sp->GetChildMemberWithName("__l",
                                                           /*can_create=*/true);
   if (!l)
     return {};
 
   StringLayout layout = l->GetIndexOfChildWithName(ConstString("__data_")) == 0
                             ? StringLayout::DSC
                             : StringLayout::CSD;
 
   bool short_mode = false; // this means the string is in short-mode and the
                            // data is stored inline
   bool using_bitmasks = true; // Whether the class uses bitmasks for the mode
                               // flag (pre-D123580).
   uint64_t size;
   uint64_t size_mode_value = 0;
 
-  ValueObjectSP short_sp = valobj_rep_sp->GetChildMemberWithName(
-      ConstString("__s"), /*can_create=*/true);
+  ValueObjectSP short_sp =
+      valobj_rep_sp->GetChildMemberWithName("__s", /*can_create=*/true);
   if (!short_sp)
     return {};
 
-  ValueObjectSP is_long =
-      short_sp->GetChildMemberWithName(ConstString("__is_long_"), true);
+  ValueObjectSP is_long = short_sp->GetChildMemberWithName("__is_long_", true);
   ValueObjectSP size_sp =
       short_sp->GetChildAtNamePath({ConstString("__size_")});
   if (!size_sp)
     return {};
 
   if (is_long) {
     using_bitmasks = false;
     short_mode = !is_long->GetValueAsUnsigned(/*fail_value=*/0);
     size = size_sp->GetValueAsUnsigned(/*fail_value=*/0);
   } else {
     // The string mode is encoded in the size field.
     size_mode_value = size_sp->GetValueAsUnsigned(0);
     uint8_t mode_mask = layout == StringLayout::DSC ? 0x80 : 1;
     short_mode = (size_mode_value & mode_mask) == 0;
   }
 
   if (short_mode) {
     ValueObjectSP location_sp =
-        short_sp->GetChildMemberWithName(ConstString("__data_"), true);
+        short_sp->GetChildMemberWithName("__data_", true);
     if (using_bitmasks)
       size = (layout == StringLayout::DSC) ? size_mode_value
                                            : ((size_mode_value >> 1) % 256);
 
     // When the small-string optimization takes place, the data must fit in the
     // inline string buffer (23 bytes on x86_64/Darwin). If it doesn't, it's
     // likely that the string isn't initialized and we're reading garbage.
     ExecutionContext exe_ctx(location_sp->GetExecutionContextRef());
     const std::optional<uint64_t> max_bytes =
         location_sp->GetCompilerType().GetByteSize(
             exe_ctx.GetBestExecutionContextScope());
     if (!max_bytes || size > *max_bytes || !location_sp)
       return {};
 
     return std::make_pair(size, location_sp);
   }
 
   // we can use the layout_decider object as the data pointer
   ValueObjectSP location_sp =
-      l->GetChildMemberWithName(ConstString("__data_"), /*can_create=*/true);
+      l->GetChildMemberWithName("__data_", /*can_create=*/true);
   ValueObjectSP size_vo =
-      l->GetChildMemberWithName(ConstString("__size_"), /*can_create=*/true);
+      l->GetChildMemberWithName("__size_", /*can_create=*/true);
   ValueObjectSP capacity_vo =
-      l->GetChildMemberWithName(ConstString("__cap_"), /*can_create=*/true);
+      l->GetChildMemberWithName("__cap_", /*can_create=*/true);
   if (!size_vo || !location_sp || !capacity_vo)
     return {};
   size = size_vo->GetValueAsUnsigned(LLDB_INVALID_OFFSET);
   uint64_t capacity = capacity_vo->GetValueAsUnsigned(LLDB_INVALID_OFFSET);
   if (!using_bitmasks && layout == StringLayout::CSD)
     capacity *= 2;
   if (size == LLDB_INVALID_OFFSET || capacity == LLDB_INVALID_OFFSET ||
       capacity < size)

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

 // ValueObjectSP
 //
 ValueObjectSP
 lldb_private::formatters::GetLibCxxAtomicValue(ValueObject &valobj) {
   ValueObjectSP non_sythetic = valobj.GetNonSyntheticValue();
   if (!non_sythetic)
     return {};
 
-  ValueObjectSP member__a_ =
-      non_sythetic->GetChildMemberWithName(ConstString("__a_"), true);
+  ValueObjectSP member__a_ = non_sythetic->GetChildMemberWithName("__a_", true);
   if (!member__a_)
     return {};
 
   ValueObjectSP member__a_value =
-      member__a_->GetChildMemberWithName(ConstString("__a_value"), true);
+      member__a_->GetChildMemberWithName("__a_value", true);
   if (!member__a_value)
     return member__a_;
 
   return member__a_value;
 }
 
 bool lldb_private::formatters::LibCxxAtomicSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {

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

lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     ~LibcxxInitializerListSyntheticFrontEnd() {
   // this needs to stay around because it's a child object who will follow its
   // parent's life cycle
   // delete m_start;
 }
 
 size_t lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     CalculateNumChildren() {
-  static ConstString g_size_("__size_");
   m_num_elements = 0;
-  ValueObjectSP size_sp(m_backend.GetChildMemberWithName(g_size_, true));
+  ValueObjectSP size_sp(m_backend.GetChildMemberWithName("__size_", true));
   if (size_sp)
     m_num_elements = size_sp->GetValueAsUnsigned(0);
   return m_num_elements;
 }
 
 lldb::ValueObjectSP lldb_private::formatters::
     LibcxxInitializerListSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
   if (!m_start)
     return lldb::ValueObjectSP();
 
   uint64_t offset = idx * m_element_size;
   offset = offset + m_start->GetValueAsUnsigned(0);
   StreamString name;
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   return CreateValueObjectFromAddress(name.GetString(), offset,
                                       m_backend.GetExecutionContextRef(),
                                       m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     Update() {
-  static ConstString g_begin_("__begin_");
-
   m_start = nullptr;
   m_num_elements = 0;
   m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
   if (!m_element_type.IsValid())
     return false;
 
   if (std::optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
     m_element_size = *size;
     // Store raw pointers or end up with a circular dependency.
-    m_start = m_backend.GetChildMemberWithName(g_begin_, true).get();
+    m_start = m_backend.GetChildMemberWithName("__begin_", true).get();
   }
 
   return false;
 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     MightHaveChildren() {
   return true;

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

 class ListEntry {
 public:
   ListEntry() = default;
   ListEntry(ValueObjectSP entry_sp) : m_entry_sp(std::move(entry_sp)) {}
   ListEntry(ValueObject *entry)
       : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
 
   ListEntry next() {
-    static ConstString g_next("__next_");
-
     if (!m_entry_sp)
       return ListEntry();
-    return ListEntry(m_entry_sp->GetChildMemberWithName(g_next, true));
+    return ListEntry(m_entry_sp->GetChildMemberWithName("__next_", true));
   }
 
   ListEntry prev() {
-    static ConstString g_prev("__prev_");
-
     if (!m_entry_sp)
       return ListEntry();
-    return ListEntry(m_entry_sp->GetChildMemberWithName(g_prev, true));
+    return ListEntry(m_entry_sp->GetChildMemberWithName("__prev_", true));
   }
 
   uint64_t value() const {
     if (!m_entry_sp)
       return 0;
     return m_entry_sp->GetValueAsUnsigned(0);
   }
 
bool ForwardListFrontEnd::Update() {
   AbstractListFrontEnd::Update();
 
   Status err;
   ValueObjectSP backend_addr(m_backend.AddressOf(err));
   if (err.Fail() || !backend_addr)
     return false;
 
   ValueObjectSP impl_sp(
-      m_backend.GetChildMemberWithName(ConstString("__before_begin_"), true));
+      m_backend.GetChildMemberWithName("__before_begin_", true));
   if (!impl_sp)
     return false;
   impl_sp = GetFirstValueOfLibCXXCompressedPair(*impl_sp);
   if (!impl_sp)
     return false;
-  m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get();
+  m_head = impl_sp->GetChildMemberWithName("__next_", true).get();
   return false;
 }
 
 ListFrontEnd::ListFrontEnd(lldb::ValueObjectSP valobj_sp)
     : AbstractListFrontEnd(*valobj_sp) {
   if (valobj_sp)
     Update();
 }
 
 size_t ListFrontEnd::CalculateNumChildren() {
   if (m_count != UINT32_MAX)
     return m_count;
   if (!m_head || !m_tail || m_node_address == 0)
     return 0;
   ValueObjectSP size_alloc(
-      m_backend.GetChildMemberWithName(ConstString("__size_alloc_"), true));
+      m_backend.GetChildMemberWithName("__size_alloc_", true));
   if (size_alloc) {
     ValueObjectSP value = GetFirstValueOfLibCXXCompressedPair(*size_alloc);
     if (value) {
       m_count = value->GetValueAsUnsigned(UINT32_MAX);
     }
   }
   if (m_count != UINT32_MAX) {
     return m_count;
bool ListFrontEnd::Update() {
 
   Status err;
   ValueObjectSP backend_addr(m_backend.AddressOf(err));
   if (err.Fail() || !backend_addr)
     return false;
   m_node_address = backend_addr->GetValueAsUnsigned(0);
   if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS)
     return false;
-  ValueObjectSP impl_sp(
-      m_backend.GetChildMemberWithName(ConstString("__end_"), true));
+  ValueObjectSP impl_sp(m_backend.GetChildMemberWithName("__end_", true));
   if (!impl_sp)
     return false;
-  m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get();
-  m_tail = impl_sp->GetChildMemberWithName(ConstString("__prev_"), true).get();
+  m_head = impl_sp->GetChildMemberWithName("__next_", true).get();
+  m_tail = impl_sp->GetChildMemberWithName("__prev_", true).get();
   return false;
 }
 
 SyntheticChildrenFrontEnd *formatters::LibcxxStdListSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   return (valobj_sp ? new ListFrontEnd(valobj_sp) : nullptr);
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxStdForwardListSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   return valobj_sp ? new ForwardListFrontEnd(*valobj_sp) : nullptr;
 }

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

lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     LibcxxStdMapSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type(), m_iterators() {
   if (valobj_sp)
     Update();
 }
 
 size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     CalculateNumChildren() {
-  static ConstString g_pair3_("__pair3_");
-  static ConstString g_first_("__first_");
-  static ConstString g_value_("__value_");
-
   if (m_count != UINT32_MAX)
     return m_count;
   if (m_tree == nullptr)
     return 0;
-  ValueObjectSP m_item(m_tree->GetChildMemberWithName(g_pair3_, true));
+  ValueObjectSP m_item(m_tree->GetChildMemberWithName("__pair3_", true));
   if (!m_item)
     return 0;
 
   switch (m_item->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
-    m_item = m_item->GetChildMemberWithName(g_first_, true);
+    m_item = m_item->GetChildMemberWithName("__first_", true);
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent = m_item->GetChildAtIndex(0, true);
-    m_item = first_elem_parent->GetChildMemberWithName(g_value_, true);
+    m_item = first_elem_parent->GetChildMemberWithName("__value_", true);
     break;
   }
   default:
     return false;
   }
 
   if (!m_item)
     return 0;
   m_count = m_item->GetValueAsUnsigned(0);
   return m_count;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() {
-  static ConstString g_value_("__value_");
   static ConstString g_tree_("__tree_");
   static ConstString g_pair3("__pair3_");
 
   if (m_element_type.IsValid())
     return true;
   m_element_type.Clear();
   ValueObjectSP deref;
   Status error;
   deref = m_root_node->Dereference(error);
   if (!deref || error.Fail())
     return false;
-  deref = deref->GetChildMemberWithName(g_value_, true);
+  deref = deref->GetChildMemberWithName("__value_", true);
   if (deref) {
     m_element_type = deref->GetCompilerType();
     return true;
   }
   deref = m_backend.GetChildAtNamePath({g_tree_, g_pair3});
   if (!deref)
     return false;
   m_element_type = deref->GetCompilerType()
void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset(
   }
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
     size_t idx) {
   static ConstString g_cc_("__cc_"), g_cc("__cc");
   static ConstString g_nc("__nc");
-  static ConstString g_value_("__value_");
 
   if (idx >= CalculateNumChildren())
     return lldb::ValueObjectSP();
   if (m_tree == nullptr || m_root_node == nullptr)
     return lldb::ValueObjectSP();
 
   MapIterator iterator(m_root_node, CalculateNumChildren());
 
if (GetDataType()) {
     if (!need_to_skip) {
       Status error;
       iterated_sp = iterated_sp->Dereference(error);
       if (!iterated_sp || error.Fail()) {
         m_tree = nullptr;
         return lldb::ValueObjectSP();
       }
       GetValueOffset(iterated_sp);
-      auto child_sp = iterated_sp->GetChildMemberWithName(g_value_, true);
+      auto child_sp = iterated_sp->GetChildMemberWithName("__value_", true);
       if (child_sp)
         iterated_sp = child_sp;
       else
         iterated_sp = iterated_sp->GetSyntheticChildAtOffset(
             m_skip_size, m_element_type, true);
       if (!iterated_sp) {
         m_tree = nullptr;
         return lldb::ValueObjectSP();
if (potential_child_sp) {
     }
     }
   }
   m_iterators[idx] = iterator;
   return potential_child_sp;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() {
-  static ConstString g_tree_("__tree_");
-  static ConstString g_begin_node_("__begin_node_");
   m_count = UINT32_MAX;
   m_tree = m_root_node = nullptr;
   m_iterators.clear();
-  m_tree = m_backend.GetChildMemberWithName(g_tree_, true).get();
+  m_tree = m_backend.GetChildMemberWithName("__tree_", true).get();
   if (!m_tree)
     return false;
-  m_root_node = m_tree->GetChildMemberWithName(g_begin_node_, true).get();
+  m_root_node = m_tree->GetChildMemberWithName("__begin_node_", true).get();
   return false;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 

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

private:
   // is destroyed, so we must not store a shared pointer to any ValueObject
   // derived from our backend ValueObject (since we're in the same cluster).
   ValueObject* m_container_sp = nullptr;
 };
 } // namespace
 
 bool QueueFrontEnd::Update() {
   m_container_sp = nullptr;
-  ValueObjectSP c_sp = m_backend.GetChildMemberWithName(ConstString("c"), true);
+  ValueObjectSP c_sp = m_backend.GetChildMemberWithName("c", true);
   if (!c_sp)
     return false;
   m_container_sp = c_sp->GetSyntheticValue().get();
   return false;
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxQueueFrontEndCreator(CXXSyntheticChildren *,
                                        lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new QueueFrontEnd(*valobj_sp);
   return nullptr;
 }

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

 };
 }
 
 bool TupleFrontEnd::Update() {
   m_elements.clear();
   m_base = nullptr;
 
   ValueObjectSP base_sp;
-  base_sp = m_backend.GetChildMemberWithName(ConstString("__base_"), true);
+  base_sp = m_backend.GetChildMemberWithName("__base_", true);
   if (!base_sp) {
     // Pre r304382 name of the base element.
-    base_sp = m_backend.GetChildMemberWithName(ConstString("base_"), true);
+    base_sp = m_backend.GetChildMemberWithName("base_", true);
   }
   if (!base_sp)
     return false;
   m_base = base_sp.get();
   m_elements.assign(base_sp->GetCompilerType().GetNumDirectBaseClasses(),
                     nullptr);
   return false;
 }

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

while (idx >= m_elements_cache.size()) {
     if (m_next_element == nullptr)
       return lldb::ValueObjectSP();
 
     Status error;
     ValueObjectSP node_sp = m_next_element->Dereference(error);
     if (!node_sp || error.Fail())
       return lldb::ValueObjectSP();
 
-    ValueObjectSP value_sp =
-        node_sp->GetChildMemberWithName(ConstString("__value_"), true);
-    ValueObjectSP hash_sp =
-        node_sp->GetChildMemberWithName(ConstString("__hash_"), true);
+    ValueObjectSP value_sp = node_sp->GetChildMemberWithName("__value_", true);
+    ValueObjectSP hash_sp = node_sp->GetChildMemberWithName("__hash_", true);
     if (!hash_sp || !value_sp) {
       if (!m_element_type) {
         auto p1_sp = m_backend.GetChildAtNamePath({ConstString("__table_"),
                                                    ConstString("__p1_")});
         if (!p1_sp)
           return nullptr;
 
         ValueObjectSP first_sp = nullptr;
         switch (p1_sp->GetCompilerType().GetNumDirectBaseClasses()) {
         case 1:
           // Assume a pre llvm r300140 __compressed_pair implementation:
-          first_sp = p1_sp->GetChildMemberWithName(ConstString("__first_"),
-                                                   true);
+          first_sp = p1_sp->GetChildMemberWithName("__first_", true);
           break;
         case 2: {
           // Assume a post llvm r300140 __compressed_pair implementation:
           ValueObjectSP first_elem_parent_sp =
             p1_sp->GetChildAtIndex(0, true);
-          first_sp = p1_sp->GetChildMemberWithName(ConstString("__value_"),
-                                                   true);
+          first_sp = p1_sp->GetChildMemberWithName("__value_", true);
           break;
         }
         default:
           return nullptr;
         }
 
         if (!first_sp)
           return nullptr;
if (!hash_sp || !value_sp) {
           CompilerType actual_type = field_type.GetTypedefedType();
           if (isStdTemplate(actual_type.GetTypeName(), "pair"))
             m_element_type = actual_type;
         }
       }
       if (!m_node_type)
         return nullptr;
       node_sp = node_sp->Cast(m_node_type);
-      value_sp = node_sp->GetChildMemberWithName(ConstString("__value_"), true);
-      hash_sp = node_sp->GetChildMemberWithName(ConstString("__hash_"), true);
+      value_sp = node_sp->GetChildMemberWithName("__value_", true);
+      hash_sp = node_sp->GetChildMemberWithName("__hash_", true);
       if (!value_sp || !hash_sp)
         return nullptr;
     }
     m_elements_cache.push_back(
         {value_sp.get(), hash_sp->GetValueAsUnsigned(0)});
-    m_next_element =
-        node_sp->GetChildMemberWithName(ConstString("__next_"), true).get();
+    m_next_element = node_sp->GetChildMemberWithName("__next_", true).get();
     if (!m_next_element || m_next_element->GetValueAsUnsigned(0) == 0)
       m_next_element = nullptr;
   }
 
   std::pair<ValueObject *, uint64_t> val_hash = m_elements_cache[idx];
   if (!val_hash.first)
     return lldb::ValueObjectSP();
   StreamString stream;
return CreateValueObjectFromData(stream.GetString(), data, exe_ctx,
                                    m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
     Update() {
   m_num_elements = 0;
   m_next_element = nullptr;
   m_elements_cache.clear();
-  ValueObjectSP table_sp =
-      m_backend.GetChildMemberWithName(ConstString("__table_"), true);
+  ValueObjectSP table_sp = m_backend.GetChildMemberWithName("__table_", true);
   if (!table_sp)
     return false;
 
-  ValueObjectSP p2_sp = table_sp->GetChildMemberWithName(
-    ConstString("__p2_"), true);
+  ValueObjectSP p2_sp = table_sp->GetChildMemberWithName("__p2_", true);
   ValueObjectSP num_elements_sp = nullptr;
   llvm::SmallVector<ConstString, 3> next_path;
   switch (p2_sp->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
-    num_elements_sp = p2_sp->GetChildMemberWithName(
-      ConstString("__first_"), true);
+    num_elements_sp = p2_sp->GetChildMemberWithName("__first_", true);
     next_path.append({ConstString("__p1_"), ConstString("__first_"),
                       ConstString("__next_")});
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent = p2_sp->GetChildAtIndex(0, true);
-    num_elements_sp = first_elem_parent->GetChildMemberWithName(
-      ConstString("__value_"), true);
+    num_elements_sp =
+        first_elem_parent->GetChildMemberWithName("__value_", true);
     next_path.append({ConstString("__p1_"), ConstString("__value_"),
                       ConstString("__next_")});
     break;
   }
   default:
     return false;
   }
 

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

case 4:
     return static_cast<uint32_t>(-1);
   }
   lldbassert(false && "Unknown index type size");
   return static_cast<uint32_t>(-1); // Fallback to stable ABI type.
 }
 
 LibcxxVariantIndexValidity
 LibcxxVariantGetIndexValidity(ValueObjectSP &impl_sp) {
-  ValueObjectSP index_sp(
-      impl_sp->GetChildMemberWithName(ConstString("__index"), true));
+  ValueObjectSP index_sp(impl_sp->GetChildMemberWithName("__index", true));
 
   if (!index_sp)
     return LibcxxVariantIndexValidity::Invalid;
 
   // In the stable ABI, the type of __index is just int.
   // In the unstable ABI, where _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION is
   // enabled, the type can either be unsigned char/short/int depending on
   // how many variant types there are.
LibcxxVariantGetIndexValidity(ValueObjectSP &impl_sp) {
 
   if (index_value == npos_value)
     return LibcxxVariantIndexValidity::NPos;
 
   return LibcxxVariantIndexValidity::Valid;
 }
 
 std::optional<uint64_t> LibcxxVariantIndexValue(ValueObjectSP &impl_sp) {
-  ValueObjectSP index_sp(
-      impl_sp->GetChildMemberWithName(ConstString("__index"), true));
+  ValueObjectSP index_sp(impl_sp->GetChildMemberWithName("__index", true));
 
   if (!index_sp)
     return {};
 
   return {index_sp->GetValueAsUnsigned(0)};
 }
 
 ValueObjectSP LibcxxVariantGetNthHead(ValueObjectSP &impl_sp, uint64_t index) {
-  ValueObjectSP data_sp(
-      impl_sp->GetChildMemberWithName(ConstString("__data"), true));
+  ValueObjectSP data_sp(impl_sp->GetChildMemberWithName("__data", true));
 
   if (!data_sp)
     return ValueObjectSP{};
 
   ValueObjectSP current_level = data_sp;
   for (uint64_t n = index; n != 0; --n) {
     ValueObjectSP tail_sp(
-        current_level->GetChildMemberWithName(ConstString("__tail"), true));
+        current_level->GetChildMemberWithName("__tail", true));
 
     if (!tail_sp)
       return ValueObjectSP{};
 
     current_level = tail_sp;
   }
 
-  return current_level->GetChildMemberWithName(ConstString("__head"), true);
+  return current_level->GetChildMemberWithName("__head", true);
 }
 } // namespace
 
 namespace lldb_private {
 namespace formatters {
 bool LibcxxVariantSummaryProvider(ValueObject &valobj, Stream &stream,
                                   const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
ValueObjectSP VariantFrontEnd::GetChildAtIndex(size_t idx) {
   if (!head_type)
     return {};
 
   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
 
   if (!template_type)
     return {};
 
-  ValueObjectSP head_value(
-      nth_head->GetChildMemberWithName(ConstString("__value"), true));
+  ValueObjectSP head_value(nth_head->GetChildMemberWithName("__value", true));
 
   if (!head_value)
     return {};
 
   return head_value->Clone(ConstString("Value"));
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
                                          lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new VariantFrontEnd(*valobj_sp);
   return nullptr;
 }

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

lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex(
   return CreateValueObjectFromAddress(name.GetString(), offset,
                                       m_backend.GetExecutionContextRef(),
                                       m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
   m_start = m_finish = nullptr;
   ValueObjectSP data_type_finder_sp(
-      m_backend.GetChildMemberWithName(ConstString("__end_cap_"), true));
+      m_backend.GetChildMemberWithName("__end_cap_", true));
   if (!data_type_finder_sp)
     return false;
 
   switch (data_type_finder_sp->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
-    data_type_finder_sp = data_type_finder_sp->GetChildMemberWithName(
-      ConstString("__first_"), true);
+    data_type_finder_sp =
+        data_type_finder_sp->GetChildMemberWithName("__first_", true);
     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 = first_elem_parent_sp->GetChildMemberWithName(
-      ConstString("__value_"), true);
+    data_type_finder_sp =
+        first_elem_parent_sp->GetChildMemberWithName("__value_", true);
     break;
   }
   default:
     return false;
   }
 
   if (!data_type_finder_sp)
     return false;
   m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType();
   if (std::optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
     m_element_size = *size;
 
     if (m_element_size > 0) {
       // store raw pointers or end up with a circular dependency
-      m_start =
-          m_backend.GetChildMemberWithName(ConstString("__begin_"), true).get();
-      m_finish =
-          m_backend.GetChildMemberWithName(ConstString("__end_"), true).get();
+      m_start = m_backend.GetChildMemberWithName("__begin_", true).get();
+      m_finish = m_backend.GetChildMemberWithName("__end_", true).get();
     }
   }
   return false;
 }
 
 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
     MightHaveChildren() {
   return true;

  }*/
 
 bool lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() {
   m_children.clear();
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
-  ValueObjectSP size_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__size_"), true));
+  ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName("__size_", true));
   if (!size_sp)
     return false;
   m_count = size_sp->GetValueAsUnsigned(0);
   if (!m_count)
     return true;
-  ValueObjectSP begin_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__begin_"), true));
+  ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName("__begin_", true));
   if (!begin_sp) {
     m_count = 0;
     return false;
   }
   m_base_data_address = begin_sp->GetValueAsUnsigned(0);
   if (!m_base_data_address) {
     m_count = 0;
     return false;

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

if (!target_sp)
     return false;
 
   bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8);
 
   if (!valobj_sp)
     return false;
   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 
-  ValueObjectSP _M_node_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("_M_node"), true));
+  ValueObjectSP _M_node_sp(valobj_sp->GetChildMemberWithName("_M_node", true));
   if (!_M_node_sp)
     return false;
 
   m_pair_address = _M_node_sp->GetValueAsUnsigned(0);
   if (m_pair_address == 0)
     return false;
 
   m_pair_address += (is_64bit ? 32 : 16);
bool LibStdcppSharedPtrSyntheticFrontEnd::Update() {
   auto backend = m_backend.GetSP();
   if (!backend)
     return false;
 
   auto valobj_sp = backend->GetNonSyntheticValue();
   if (!valobj_sp)
     return false;
 
-  auto ptr_obj_sp = valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true);
+  auto ptr_obj_sp = valobj_sp->GetChildMemberWithName("_M_ptr", true);
   if (!ptr_obj_sp)
     return false;
 
   m_ptr_obj = ptr_obj_sp->Clone(ConstString("pointer")).get();
 
   if (m_ptr_obj) {
     Status error;
     ValueObjectSP obj_obj = m_ptr_obj->Dereference(error);

 }
 
 bool lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("_M_ptr", true));
   if (!ptr_sp)
     return false;
 
   ValueObjectSP usecount_sp(valobj_sp->GetChildAtNamePath(
       {ConstString("_M_refcount"), ConstString("_M_pi"),
        ConstString("_M_use_count")}));
   if (!usecount_sp)
     return false;

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

while (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);
       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(ConstString("_M_head_impl"), true);
+            child_sp->GetChildMemberWithName("_M_head_impl", true);
         if (value_sp) {
           StreamString name;
           name.Printf("[%zd]", m_members.size());
           m_members.push_back(value_sp->Clone(ConstString(name.GetString())).get());
         }
       }
     }
   }

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

ValueObjectSP LibStdcppUniquePtrSyntheticFrontEnd::GetTuple() {
 
   if (!valobj_backend_sp)
     return nullptr;
 
   ValueObjectSP valobj_sp = valobj_backend_sp->GetNonSyntheticValue();
   if (!valobj_sp)
     return nullptr;
 
-  ValueObjectSP obj_child_sp =
-      valobj_sp->GetChildMemberWithName(ConstString("_M_t"), true);
+  ValueObjectSP obj_child_sp = valobj_sp->GetChildMemberWithName("_M_t", true);
   if (!obj_child_sp)
       return nullptr;
 
   ValueObjectSP obj_subchild_sp =
-      obj_child_sp->GetChildMemberWithName(ConstString("_M_t"), true);
+      obj_child_sp->GetChildMemberWithName("_M_t", true);
 
   // if there is a _M_t subchild, the tuple is found in the obj_subchild_sp
   // (for libstdc++ 6.0.23).
   if (obj_subchild_sp) {
     return obj_subchild_sp;
   }
 
   return obj_child_sp;

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
   //    this entry and lookup operator()() and obtain the line table entry.
   // 3) a callable object via operator()(). We will obtain the name of the
   //    object from the first template parameter from __func's vtable. We will
   //    look up the objects operator()() and obtain the line table entry.
   // 4) a member function. A pointer to the function will stored after the
   //    we will obtain the name from this pointer.
   // 5) a free function. A pointer to the function will stored after the vtable
   //    we will obtain the name from this pointer.
-  ValueObjectSP member_f_(
-      valobj_sp->GetChildMemberWithName(ConstString("__f_"), true));
+  ValueObjectSP member_f_(valobj_sp->GetChildMemberWithName("__f_", true));
 
   if (member_f_) {
     ValueObjectSP sub_member_f_(
-       member_f_->GetChildMemberWithName(ConstString("__f_"), true));
+        member_f_->GetChildMemberWithName("__f_", true));
 
     if (sub_member_f_)
         member_f_ = sub_member_f_;
   }
 
   if (!member_f_)
     return optional_info;
 

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

static ThreadSP FailExceptionParsing(llvm::StringRef msg) {
   Log *log = GetLog(LLDBLog::Language);
   LLDB_LOG(log, "Failed getting backtrace from exception: {0}", msg);
   return ThreadSP();
 }
 
 ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
     lldb::ValueObjectSP exception_sp) {
   ValueObjectSP reserved_dict =
-      exception_sp->GetChildMemberWithName(ConstString("reserved"), true);
+      exception_sp->GetChildMemberWithName("reserved", true);
   if (!reserved_dict)
     return FailExceptionParsing("Failed to get 'reserved' member.");
 
   reserved_dict = reserved_dict->GetSyntheticValue();
   if (!reserved_dict)
     return FailExceptionParsing("Failed to get synthetic value.");
 
   TypeSystemClangSP scratch_ts_sp =
if (lldb_private::formatters::NSStringSummaryProvider(
                                                     "callStackReturnAddresses");
         break;
       }
     }
   }
 
   if (!return_addresses)
     return FailExceptionParsing("Failed to get return addresses.");
-  auto frames_value =
-      return_addresses->GetChildMemberWithName(ConstString("_frames"), true);
+  auto frames_value = return_addresses->GetChildMemberWithName("_frames", true);
   if (!frames_value)
     return FailExceptionParsing("Failed to get frames_value.");
   addr_t frames_addr = frames_value->GetValueAsUnsigned(0);
-  auto count_value =
-      return_addresses->GetChildMemberWithName(ConstString("_cnt"), true);
+  auto count_value = return_addresses->GetChildMemberWithName("_cnt", true);
   if (!count_value)
     return FailExceptionParsing("Failed to get count_value.");
   size_t count = count_value->GetValueAsUnsigned(0);
-  auto ignore_value =
-      return_addresses->GetChildMemberWithName(ConstString("_ignore"), true);
+  auto ignore_value = return_addresses->GetChildMemberWithName("_ignore", true);
   if (!ignore_value)
     return FailExceptionParsing("Failed to get ignore_value.");
   size_t ignore = ignore_value->GetValueAsUnsigned(0);
 
   size_t ptr_size = m_process->GetAddressByteSize();
   std::vector<lldb::addr_t> pcs;
   for (size_t idx = 0; idx < count; idx++) {
     Status error;