Added GDB pretty printer for StringMap

[csigg]

Thanks!

Would it be possible to the StringMap to the existing test? (Note that the debug-info tests are not run as part of the pre-merge checks, you need to run them manually).

llvm/utils/gdb-scripts/prettyprinters.py

206–207

Disclaimer: I have no Python experience.

Have you considered using a generator function? I suspect it might avoid the self.first toggle and generally make the implementation a little simpler.

[MoritzS]

• Added test case
• Use generator instead of iterator class

[MoritzS]

llvm/utils/gdb-scripts/prettyprinters.py

206–207

You are right, I haven't even thought of that. It looks much nicer as a generator function!

[csigg]

Looks great, thanks!

[dblaikie]

llvm/utils/gdb-scripts/prettyprinters.py

215

Any chance we could avoid hardcoding the tombstone value here? I guess maybe if the source were modified to store the tombstone value as a constexpr (not sure if it could be constexpr - with the pointer bitfiddling, etc - but maybe) member of StringMapImpl, would that be accessible from the pretty printer reliably?

[MoritzS]

llvm/utils/gdb-scripts/prettyprinters.py

215

I could call StringMapImpl::getTombstoneVal() from gdb to get it, but that depends on that function to not be optimized out. But this kind of function is pretty likely to be inlined and optimized out even with -O1. Even with a constexpr member I think that would have the same problems.

[dblaikie]

llvm/utils/gdb-scripts/prettyprinters.py

215

Yeah, relying on a function call would be problematic for the reason you mentioned & for the fact that then you can't debug a core dump (because you can't execute the function) and otherwise risk corrupting the target process by running code when trying to pretty print.

But I don't think Clang will optimize out a constexpr member & the value could be queried without executing code:

$ clang++-tot constexpr.cpp -g -c -O3 && llvm-dwarfdump-tot constexpr.o
constexpr.o:    file format elf64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000052, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000056)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer    ("clang version 12.0.0 ([e-mail]:llvm/llvm-project.git 2c196bbc6bd897b3dcc1d87a3baac28e1e88df41)")
              DW_AT_language    (DW_LANG_C_plus_plus_14)
              DW_AT_name        ("constexpr.cpp")
              DW_AT_stmt_list   (0x00000000)
              DW_AT_comp_dir    ("/usr/local/google/home/blaikie/dev/scratch")

0x0000001e:   DW_TAG_variable
                DW_AT_name      ("f")
                DW_AT_type      (0x00000033 "foo")
                DW_AT_external  (true)
                DW_AT_decl_file ("/usr/local/google/home/blaikie/dev/scratch/constexpr.cpp")
                DW_AT_decl_line (4)
                DW_AT_location  (DW_OP_addr 0x0)

0x00000033:   DW_TAG_structure_type
                DW_AT_calling_convention        (DW_CC_pass_by_value)
                DW_AT_name      ("foo")
                DW_AT_byte_size (0x01)
                DW_AT_decl_file ("/usr/local/google/home/blaikie/dev/scratch/constexpr.cpp")
                DW_AT_decl_line (1)

0x0000003c:     DW_TAG_member
                  DW_AT_name    ("i")
                  DW_AT_type    (0x00000049 "const int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/constexpr.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_external        (true)
                  DW_AT_declaration     (true)
                  DW_AT_const_value     (7)

0x00000048:     NULL

0x00000049:   DW_TAG_const_type
                DW_AT_type      (0x0000004e "int")

0x0000004e:   DW_TAG_base_type
                DW_AT_name      ("int")
                DW_AT_encoding  (DW_ATE_signed)
                DW_AT_byte_size (0x04)

0x00000055:   NULL
blaikie@blaikie-linux2:~/dev/scratch$ cat constexpr.cpp
struct foo {
  static constexpr int i = 7;
};
foo f;

[MoritzS]

Read tombstone value from a constexpr variable. The getTombstoneVal() function
is still necessary, though, as reinterpret_cast is not a constant expression.

[MoritzS]

llvm/utils/gdb-scripts/prettyprinters.py

215

You are right, it also works with gcc! I changed it.

[dblaikie]

llvm/utils/gdb-scripts/prettyprinters.py

215

Awesome, thanks for that!

[MoritzS]

Can you commit this please? I don't have commit access.

debuginfo-tests/llvm-prettyprinters/gdb/llvm-support.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/Support/Error.h"
 
 int Array[] = {1, 2, 3};
 auto IntPtr = reinterpret_cast<int *>(0xabc);
 
 llvm::ArrayRef<int> ArrayRef(Array);
 llvm::MutableArrayRef<int> MutableArrayRef(Array);
 llvm::DenseMap<int, int> DenseMap = {{4, 5}, {6, 7}};
+llvm::StringMap<int> StringMap = {{"foo", 123}, {"bar", 456}};
 llvm::Expected<int> ExpectedValue(8);
 llvm::Expected<int> ExpectedError(llvm::createStringError({}, ""));
 llvm::Optional<int> OptionalValue(9);
 llvm::Optional<int> OptionalNone(llvm::None);
 llvm::SmallVector<int, 5> SmallVector = {10, 11, 12};
 llvm::SmallString<5> SmallString("foo");
 llvm::StringRef StringRef = "bar";
 llvm::Twine Twine = llvm::Twine(SmallString) + StringRef;

debuginfo-tests/llvm-prettyprinters/gdb/llvm-support.gdb

 p SmallString
 
 # CHECK: "bar"
 p StringRef
 
 # CHECK: "\"foo\"\"bar\""
 p Twine
 
+# CHECK: llvm::StringMap with 2 elements = {["foo"] = 123, ["bar"] = 456}
+p StringMap
+
 # CHECK: {pointer = 0xabc, value = 1}
 p PointerIntPair
 
 # CHECK: Containing int * = {pointer = 0xabc}
 p PointerUnion
 
 # CHECK: PointerUnionMembers<llvm::PointerUnion<Z*, float*>,
 p RawPrintingPointerUnion

llvm/include/llvm/ADT/StringMap.h

protected:
   /// table, returning it.  If the key is not in the table, this returns null.
   StringMapEntryBase *RemoveKey(StringRef Key);
 
   /// Allocate the table with the specified number of buckets and otherwise
   /// setup the map as empty.
   void init(unsigned Size);
 
 public:
+  static constexpr uintptr_t TombstoneIntVal =
+      static_cast<uintptr_t>(-1)
+      << PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
+
   static StringMapEntryBase *getTombstoneVal() {
-    uintptr_t Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
-    return reinterpret_cast<StringMapEntryBase *>(Val);
+    return reinterpret_cast<StringMapEntryBase *>(TombstoneIntVal);
   }
 
   unsigned getNumBuckets() const { return NumBuckets; }
   unsigned getNumItems() const { return NumItems; }
 
   bool empty() const { return NumItems == 0; }
   unsigned size() const { return NumItems; }
 

llvm/utils/gdb-scripts/prettyprinters.py

 from __future__ import print_function
+import struct
 import sys
 
 import gdb.printing
 import gdb.types
 
 class Iterator:
   def __iter__(self):
     return self
def children(self):
     return self._iterator(self.val.type.template_argument(2), begin, end)
 
   def to_string(self):
     return 'llvm::DenseMap with %d elements' % (self.val['NumEntries'])
 
   def display_hint(self):
     return 'map'
 
+class StringMapPrinter:
+  "Print a StringMap"
+
+  def __init__(self, val):
+    self.val = val
+
+  def children(self):
+    it = self.val['TheTable']
+    end = (it + self.val['NumBuckets'])
+    value_ty = self.val.type.template_argument(0)
+    entry_ty = gdb.lookup_type('llvm::StringMapEntry<{}>'.format(value_ty.name))
+    tombstone = gdb.parse_and_eval('llvm::StringMapImpl::TombstoneIntVal');
+
+    while it != end:
+      it_deref = it.dereference()
+      if it_deref == 0 or it_deref == tombstone:
+        it = it + 1
+        continue
+
+      entry_ptr = it_deref.cast(entry_ty.pointer())
+      entry = entry_ptr.dereference()
+
+      str_len = entry['keyLength']
+      str_data = (entry_ptr + 1).cast(gdb.lookup_type('char').const().pointer())
+      string_ref = gdb.Value(struct.pack('PN', int(str_data), int(str_len)), gdb.lookup_type('llvm::StringRef'))
+      yield 'key', string_ref
+
+      value = entry['second']
+      yield 'value', value
+
+      it = it + 1
+
+  def to_string(self):
+    return 'llvm::StringMap with %d elements' % (self.val['NumItems'])
+
+  def display_hint(self):
+    return 'map'
+
 class TwinePrinter:
   "Print a Twine"
 
   def __init__(self, val):
     self._val = val
 
   def display_hint(self):
     return 'string'

 pp = gdb.printing.RegexpCollectionPrettyPrinter("LLVMSupport")
 pp.add_printer('llvm::SmallString', '^llvm::SmallString<.*>$', SmallStringPrinter)
 pp.add_printer('llvm::StringRef', '^llvm::StringRef$', StringRefPrinter)
 pp.add_printer('llvm::SmallVectorImpl', '^llvm::SmallVector(Impl)?<.*>$', SmallVectorPrinter)
 pp.add_printer('llvm::ArrayRef', '^llvm::(Mutable)?ArrayRef<.*>$', ArrayRefPrinter)
 pp.add_printer('llvm::Expected', '^llvm::Expected<.*>$', ExpectedPrinter)
 pp.add_printer('llvm::Optional', '^llvm::Optional<.*>$', OptionalPrinter)
 pp.add_printer('llvm::DenseMap', '^llvm::DenseMap<.*>$', DenseMapPrinter)
+pp.add_printer('llvm::StringMap', '^llvm::StringMap<.*>$', StringMapPrinter)
 pp.add_printer('llvm::Twine', '^llvm::Twine$', TwinePrinter)
 pp.add_printer('llvm::PointerIntPair', '^llvm::PointerIntPair<.*>$', make_pointer_int_pair_printer)
 pp.add_printer('llvm::PointerUnion', '^llvm::PointerUnion<.*>$', make_pointer_union_printer)
 pp.add_printer('llvm::ilist_node', '^llvm::ilist_node<.*>$', IlistNodePrinter)
 pp.add_printer('llvm::iplist', '^llvm::iplist<.*>$', IlistPrinter)
 pp.add_printer('llvm::simple_ilist', '^llvm::simple_ilist<.*>$', IlistPrinter)
 gdb.printing.register_pretty_printer(gdb.current_objfile(), pp)