Change to individual pretty printer classes, remove generic `make_printer`.

[csigg]

Summary

Follow-up from D72589.

[merge_guards_bot]

Unit tests: pass. 62283 tests passed, 0 failed and 827 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[csigg]

Rebase from master.

[merge_guards_bot]

Unit tests: pass. 62322 tests passed, 0 failed and 838 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[dblaikie]

llvm/utils/gdb-scripts/prettyprinters.py

322–325

I think I asked this elsewhere, but not sure there was an answer (apologies if I forgot - might be worth a comment) - what is this error case for? Are there types in LLVM that don't provide this expected nested type?

Might be nice if it could be removed & then wouldn't need the factory layer of indirection for PointerIntPair and PointerUnion below.

[csigg]

llvm/utils/gdb-scripts/prettyprinters.py

322–325

GDB gets confused about template arguments of 'std::_u::pair' (not sure I remember the exact name), and the lookup_type may fail.

Unfortunately GDB spews the console when a printer factory throws an exception, so it's better to catch it and handle it.

I will add a comment.

[csigg]

Rebase from master.

[dblaikie]

llvm/utils/gdb-scripts/prettyprinters.py

322–325

Where does std::pair come into this? The 4th template argument to PointerIntPair is the PointerLikeTypeTraits, right?

[csigg]

llvm/utils/gdb-scripts/prettyprinters.py

322–325

It's zero-based, so it's the PointerIntPairInfo, and if PointerTy is a std::pair<...>* gdb fails to look up the type.

Something like that. Is it important enough to dig up the details?

[dblaikie]

llvm/utils/gdb-scripts/prettyprinters.py

322–325

Given the existence of this error path adds complexity to how this function is used, error paths to its callers, etc - yeah, I'd like to know why it's there & have a test case for it if it's needed (but hope there might be other solutions to addressing the underlying issue that might allow the error handling to be unnecessary/avoided), etc.

[csigg]

Add test case for PointerUnion that cannot be pretty-printed.

[csigg]

Hi David, I finally had time to get back to this and spend a few hours to root cause why some PointerUnions can't be pretty printed.
It was unrelated to std::__u::pair. The issue is that the PointerUnionUIntTraits may be invisible to the current GDB block if it's only been instanced in a different translation unit.
I've added a test case to show the issue.

[dblaikie]

Dandy - thanks a bunch!

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

 p SmallString
 
 # CHECK: "bar"
 p StringRef
 
 # CHECK: "\"foo\"\"bar\""
 p Twine
 
-# CHECK: llvm::PointerIntPair<int *> = {pointer = 0xabc, value = 1}
+# CHECK: {pointer = 0xabc, value = 1}
 p PointerIntPair
 
-# CHECK: llvm::PointerUnion containing int * = {pointer = 0xabc}
+# CHECK: Containing int * = {pointer = 0xabc}
 p PointerUnion
 
 # Switch to print pretty adds newlines to the following statements.
 set print pretty
 
 # CHECK: {
 # CHECK:   [0] = {
 # CHECK:     <llvm::ilist_node<IlistNode, llvm::ilist_tag<A> >> = {

llvm/utils/gdb-scripts/prettyprinters.py

def string_from_twine_object(self, twine):
     lhs_str = self.string_from_child(lhs, lhs_kind)
     rhs_str = self.string_from_child(rhs, rhs_kind)
 
     return lhs_str + rhs_str
 
   def to_string(self):
     return self.string_from_twine_object(self._val)
 
-def make_printer(string = None, children = None, hint = None):
-  """Create a printer from the parameters."""
-  class Printer : pass
-  printer = Printer()
-  if string:
-    setattr(printer, 'to_string', lambda: string)
-  if children:
-    setattr(printer, 'children', lambda: children)
-  if hint:
-    setattr(printer, 'display_hint', lambda: hint)
-  return printer
-
 def get_pointer_int_pair(val):
   """Get tuple from llvm::PointerIntPair."""
   info_name = val.type.template_argument(4).strip_typedefs().name
   try:
     enum_type = gdb.lookup_type(info_name + '::MaskAndShiftConstants')
   except gdb.error:
     return (None, None)
   enum_dict = gdb.types.make_enum_dict(enum_type)
   ptr_mask = enum_dict[info_name + '::PointerBitMask']
   int_shift = enum_dict[info_name + '::IntShift']
   int_mask = enum_dict[info_name + '::IntMask']
   pair_union = val['Value']
   pointer = (pair_union & ptr_mask)
   value = ((pair_union >> int_shift) & int_mask)
   return (pointer, value)
 
+class PointerIntPairPrinter:
+  """Print a PointerIntPair."""
+
+  def __init__(self, pointer, value):
+    self.pointer = pointer
+    self.value = value
+
+  def children(self):
+    yield ('pointer', self.pointer)
+    yield ('value', self.value)
+
 def make_pointer_int_pair_printer(val):
   """Factory for an llvm::PointerIntPair printer."""
   pointer, value = get_pointer_int_pair(val)
   if not pointer or not value:
     return None
   pointer_type = val.type.template_argument(0)
   value_type = val.type.template_argument(2)
-  string = 'llvm::PointerIntPair<%s>' % pointer_type
-  children = [('pointer', pointer.cast(pointer_type)),
-              ('value', value.cast(value_type))]
-  return make_printer(string, children)
+  return PointerIntPairPrinter(pointer.cast(pointer_type),
+                               value.cast(value_type))
+
+class PointerUnionPrinter:
+  """Print a PointerUnion."""
+
+  def __init__(self, pointer):
+    self.pointer = pointer
+
+  def children(self):
+    yield ('pointer', self.pointer)
+
+  def to_string(self):
+    return "Containing %s" % self.pointer.type
 
 def make_pointer_union_printer(val):
   """Factory for an llvm::PointerUnion printer."""
   pointer, value = get_pointer_int_pair(val['Val'])
   if not pointer or not value:
     return None
   pointer_type = val.type.template_argument(int(value))
-  string = 'llvm::PointerUnion containing %s' % pointer_type
-  return make_printer(string, [('pointer', pointer.cast(pointer_type))])
+  return PointerUnionPrinter(pointer.cast(pointer_type))
 
 class IlistNodePrinter:
   """Print an llvm::ilist_node object."""
 
   def __init__(self, val):
     impl_type = val.type.fields()[0].type
     base_type = impl_type.fields()[0].type
     derived_type = val.type.template_argument(0)