LLDB reports empty `std::vector` when reproducer is compiled with `-D_GLIBCXX_DEBUG`

[tbaederr]

Using this code:

#include <cassert>
#include <vector>

int main() {
  std::vector<int> V;
  V.push_back(12);
  assert(false);
  return 0;
}

shows the correct vector size in lldb when compiled with clang++ ./vec.cpp -g -std=c++20:

~ » lldb ./a.out -o run -o ' up 5' -o 'p V' -o q
(lldb) target create "./a.out"
Current executable set to '/home/tbaeder/a.out' (x86_64).
(lldb) run
a.out: ./vec.cpp:7: int main(): Assertion `false' failed.
Process 1492018 stopped
* thread #1, name = 'a.out', stop reason = signal SIGABRT
    frame #0: 0x00007ffff788ebec libc.so.6`__pthread_kill_implementation + 284
libc.so.6`__pthread_kill_implementation:
->  0x7ffff788ebec <+284>: movl   %eax, %ebp
    0x7ffff788ebee <+286>: negl   %ebp
    0x7ffff788ebf0 <+288>: cmpl   $0xfffff000, %eax         ; imm = 0xFFFFF000
    0x7ffff788ebf5 <+293>: movl   $0x0, %eax
Process 1492018 launched: '/home/tbaeder/a.out' (x86_64)
(lldb)  up 5
frame #5: 0x000000000040122d a.out`main at vec.cpp:7:3
   4   	int main() {
   5   	  std::vector<int> V;
   6   	  V.push_back(12);
-> 7   	  assert(false);
   8   	  return 0;
   9   	}
(lldb) p V
(std::vector<int, std::allocator<int> >) $0 = size=1 {
  [0] = 12
}
(lldb) q

But when compiled with clang++ ./vec.cpp -g -std=c++20 -D_GLIBCXX_DEBUG:

~ » lldb ./a.out -o run -o ' up 5' -o 'p V' -o q
(lldb) target create "./a.out"
Current executable set to '/home/tbaeder/a.out' (x86_64).
(lldb) run
a.out: ./vec.cpp:7: int main(): Assertion `false' failed.
Process 1492120 stopped
* thread #1, name = 'a.out', stop reason = signal SIGABRT
    frame #0: 0x00007ffff788ebec libc.so.6`__pthread_kill_implementation + 284
libc.so.6`__pthread_kill_implementation:
->  0x7ffff788ebec <+284>: movl   %eax, %ebp
    0x7ffff788ebee <+286>: negl   %ebp
    0x7ffff788ebf0 <+288>: cmpl   $0xfffff000, %eax         ; imm = 0xFFFFF000
    0x7ffff788ebf5 <+293>: movl   $0x0, %eax
Process 1492120 launched: '/home/tbaeder/a.out' (x86_64)
(lldb)  up 5
frame #5: 0x00000000004012bd a.out`main at vec.cpp:7:3
   4   	int main() {
   5   	  std::vector<int> V;
   6   	  V.push_back(12);
-> 7   	  assert(false);
   8   	  return 0;
   9   	}
(lldb) p V
(std::vector<int, std::allocator<int> >) $0 = size=0 {}
(lldb) q

... the size is reported as 0, which is clearly wrong.

Using lldb 15.0.7.

[llvmbot]

@llvm/issue-subscribers-lldb

[Michael137]

That's most likely because the _GLIBCXX_DEBUG changes the layout of the vector, which the data formatter doesn't account for.

On my Ubuntu machine
With the flag the raw layout is:

(lldb) frame var --raw v
(std::__debug::vector<int, std::allocator<int> >) v = {
  __gnu_debug::_Safe_container<std::__debug::vector<int, std::allocator<int> >, std::allocator<int>, __gnu_debug::_Safe_sequence, true> = {
    __gnu_debug::_Safe_sequence<std::__debug::vector<int, std::allocator<int> > > = {
      __gnu_debug::_Safe_sequence_base = {
        _M_iterators = nullptr
        _M_const_iterators = nullptr
        _M_version = 2
      }
    }
  }
  std::__cxx1998::vector<int, std::allocator<int> > = {
    std::__cxx1998::_Vector_base<int, std::allocator<int> > = {
      _M_impl = {
        std::__cxx1998::_Vector_base<int, std::allocator<int> >::_Vector_impl_data = {
          _M_start = 0x000055555556ceb0
          _M_finish = 0x000055555556ceb4
          _M_end_of_storage = 0x000055555556ceb4
        }
      }
    }
  }
  __gnu_debug::_Safe_vector<std::__debug::vector<int, std::allocator<int> >, std::__cxx1998::vector<int, std::allocator<int> > > = {
    _M_guaranteed_capacity = 1
  }
}

(lldb) type summary info v
summary applied to (std::vector<int, std::allocator<int> >) v is:  (show children) (hide value) libc++ std::vector summary provider

(lldb) type synthetic info v
synthetic applied to (std::vector<int, std::allocator<int> >) v is:  libc++ std::vector synthetic children

Looks like the summary provider that gets used for std::__debug::vector is the one for libc++.

Whereas the regular vector looks like:

(lldb) frame var --raw v
(std::vector<int, std::allocator<int> >) v = {
  std::_Vector_base<int, std::allocator<int> > = {
    _M_impl = {
      std::_Vector_base<int, std::allocator<int> >::_Vector_impl_data = {
        _M_start = 0x000055555556aeb0
        _M_finish = 0x000055555556aeb4
        _M_end_of_storage = 0x000055555556aeb4
      }
    }
  }
}

(lldb) type summary info v
summary applied to (std::vector<int, std::allocator<int> >) v is: `size=${svar%#}` (show children) (hide value)

(lldb) type synthetic info v
synthetic applied to (std::vector<int, std::allocator<int> >) v is:  Python class lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider

I think to fix this we'd have to adjust the std::vector formatter regex to account for the __debug namespace and then implement support for this layout in StdVectorSynthProvider (which lives in gnu_libstdcpp.py).

[da-viper]

@Michael137

The like you said fix should be as simple as changing the regex for container types to match also the __debug namespace.
Assuming std::vector as container for now (this also applies to other containers).

The regex should be ^std::(__debug::)?vector<.+>(( )?&)?$

But this also conflicts the the regex for libc++ which is ^std::__[[:alnum:]]+::vector<.+>$ . This matches any alpha numeric one or more times.

the ideal answer is to change the regex for libc++ to ignore __debug namespace like so ^std::__(?!debug)[[:alnum:]]+::vector<.+>$
but the issue is that the underlying regex engine is uses the posix regex format in the type match and negative lookup is not supported.

llvm-project/lldb/include/lldb/DataFormatters/FormattersContainer.h

Lines 87 to 92 in 6d942c5

	TypeMatcher(lldb::TypeNameSpecifierImplSP type_specifier)
	: m_name(type_specifier->GetName()),
	m_match_type(type_specifier->GetMatchType()) {
	if (m_match_type == lldb::eFormatterMatchRegex)
	m_type_name_regex = RegularExpression(type_specifier->GetName());
	}

However using std::regex works fine sample

  const auto regex_str = R"(^std::__(?!debug\b)[[:alnum:]]+::vector<.+>$)";
  const auto str = "std::__1::vector<int, std::__1::allocator<int> >";
  llvm::Regex regex(regex_str, llvm::Regex::BasicRegex); // also tried llvm::Regex::NoFlag
  const std::regex txt_regex(regex_str);
  const auto c_result = std::regex_match(str , txt_regex);

  llvm::SmallVector<StringRef> matches;
  bool result = regex.match(str, &matches);

A solution would be to use the std library std::regex as this matches it correctly. or use a hack for posix ^std::__(([^d])|(d([^e]))|(de([^b]))|(deb([^u]))|(debu([^g]))|(debug[[:alnum:]]))*::vector<.+>$" but this easily becomes unmaintainable and hard to read. as it will be repeated for other container types.

I was wondering what would be the best option or if there is another option I did not think about ?

[labath]

This comes up from time to time. Two options I see are:

• use a single regex to match the type, and then dispatch to the right formatter in the implementation
• define some sort of a priority for each regex and then ensure the libstdc++ regex has a higher priority. Maybe the priority could be as simple as "the order of registration"