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

321–324

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

321–324

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

321–324

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

[csigg]

llvm/utils/gdb-scripts/prettyprinters.py

321–324

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

321–324

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.cpp

 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;
 llvm::PointerIntPair<int *, 1> PointerIntPair(IntPtr, 1);
-llvm::PointerUnion<float *, int *> PointerUnion(IntPtr);
+
+struct alignas(8) Z {};
+llvm::PointerUnion<Z *, int *> PointerUnion(IntPtr);
+
+// No members which instantiate PointerUnionUIntTraits<Z *> (e.g. get<T *>())
+// are called, and this instance will therefore be raw-printed.
+llvm::PointerUnion<Z *, float *> RawPrintingPointerUnion(nullptr);
 
 using IlistTag = llvm::ilist_tag<struct A>;
 using SimpleIlistTag = llvm::ilist_tag<struct B>;
 struct IlistNode : llvm::ilist_node<IlistNode, IlistTag>,
                    llvm::ilist_node<IlistNode, SimpleIlistTag> {
   int Value;
 };
 auto Ilist = [] {

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

-# RUN: gdb -q -batch -n -iex 'source %llvm_src_root/utils/gdb-scripts/prettyprinters.py' -x %s %llvm_tools_dir/check-gdb-llvm-support | FileCheck %s
+# RUN: gdb -q -batch -n -iex 'source %llvm_src_root/utils/gdb-scripts/prettyprinters.py' -x %s %llvm_tools_dir/check-gdb-llvm-support | FileCheck %s --dump-input-on-failure
 
 break main
 run
 
 # CHECK: llvm::ArrayRef of length 3 = {1, 2, 3}
 p ArrayRef
 
 # CHECK: llvm::ArrayRef of length 3 = {1, 2, 3}

 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
 
+# CHECK: PointerUnionMembers<llvm::PointerUnion<Z*, float*>,
+p RawPrintingPointerUnion
+
 # 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> >> = {
 # CHECK:       prev = [[Ilist_Sentinel:0x.*]] <Ilist>,
 # CHECK:       next = [[Node_14:0x.*]]

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)
+  # Note: this throws a gdb.error if the info type is not used (by means of a
+  # call to getPointer() or similar) in the current translation unit.
   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."""
+  try:
     pointer, value = get_pointer_int_pair(val)
-  if not pointer or not value:
-    return None
+  except gdb.error:
+    return None  # If PointerIntPair cannot be analyzed, print as raw value.
   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."""
+  try:
     pointer, value = get_pointer_int_pair(val['Val'])
-  if not pointer or not value:
-    return None
+  except gdb.error:
+    return None  # If PointerIntPair cannot be analyzed, print as raw value.
   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)