Add pretty-printer for llvm::Twine type

[simark]

Summary

This patch adds a basic pretty-printer for llvm::Twine.

[malaperle-ericsson]

I'm not very familiar with gdb pretty printers but I tested the patch and it works well! This will definitely help debugging.

[dblaikie]

utils/gdb-scripts/prettyprinters.py

205–219 ↗

(On Diff #91911)

This seems more complicated than I would've expected, is str(val) insufficient?

224–265 ↗

(On Diff #91911)

Rather than a long else-if chain with various assignments to 's', perhaps a more LLVM-esque style would be to return from each condition:

if kind == ...:
  return str(...)
if kind == UHexKind:
  return hex(int(val))
/* do the unsupported NodeKind thing here */

[simark]

utils/gdb-scripts/prettyprinters.py

205–219 ↗

(On Diff #91911)

That's what I did first. Actually, it was s = str(val)[1:-1], because the return of str(val) contains quotes.

But I wanted to give a better experience (a good error message) when the std::string pretty printer is not loaded (which can happen easily, as they're a bit of a pain to set up sometimes). Otherwise, you get something like this as part of the resulting string:

"foostatic npos = <optimized out>, _M_dataplus = {<std::allocator<char>> = {<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x318e1f8 \"bar\"}baz"

Instead, the goal is to print a warning:

(gdb) print twine
$1 = No pretty printer for std::string found. The resulting Twine representation will be incomplete.
"foo<std::string>baz"

What's broken is the

self.string_from_pretty_printer_lookup(val).value().address.string()

I do lower. I added that because the std::string pretty printer returns a gdb.LazyString, and that's the only way I've found to convert it to a Python string. However, it doesn't work when we return the placeholder <std::string>.

The other thing is that a <std::string> placeholder looks very much like a C++ template, so it's probably not a very good choice. I wanted to add something to the string to make the user realize that something should be there but is missing, but that format probably looks too much like some "valid" content.

[simark]

• Add return statements in the if-else chain
• Fix case when std::string pretty printer is not loaded

[simark]

utils/gdb-scripts/prettyprinters.py

217 ↗

(On Diff #91919)

This is really ugly, but I didn't find any other way to check if the return is of that type. GDB doesn't seem to register the LazyString type:

>>> gdb.Value
<type 'gdb.Value'>
>>> gdb.LazyString
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'LazyString'

so I can't do type(s) == gdb.LazyString...

[dblaikie]

Looks good (one minor thing to fix up further - the elifs) & thanks for explaining the stringification issue. Maybe add some comments there about why it's needed/useful, if you like (& why the type comparison is difficult/awkward)

utils/gdb-scripts/prettyprinters.py

232–264 ↗

(On Diff #91919)

Remove the "el"/elses here - since each condition unconditionally returns:

if ...:
  return
if ...:
  return
return '(unhandled...

[simark]

Formatting and comments.

llvm/trunk/utils/gdb-scripts/prettyprinters.py

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 TwinePrinter:
+  "Print a Twine"
+
+  def __init__(self, val):
+    self._val = val
+
+  def display_hint(self):
+    return 'string'
+
+  def string_from_pretty_printer_lookup(self, val):
+    '''Lookup the default pretty-printer for val and use it.
+
+    If no pretty-printer is defined for the type of val, print an error and
+    return a placeholder string.'''
+
+    pp = gdb.default_visualizer(val)
+    if pp:
+      s = pp.to_string()
+
+      # The pretty-printer may return a LazyString instead of an actual Python
+      # string.  Convert it to a Python string.  However, GDB doesn't seem to
+      # register the LazyString type, so we can't check
+      # "type(s) == gdb.LazyString".
+      if 'LazyString' in type(s).__name__:
+        s = s.value().address.string()
+
+    else:
+      print(('No pretty printer for {} found. The resulting Twine ' +
+             'representation will be incomplete.').format(val.type.name))
+      s = '(missing {})'.format(val.type.name)
+
+    return s
+
+  def string_from_child(self, child, kind):
+    '''Return the string representation of the Twine::Child child.'''
+
+    if kind in ('llvm::Twine::EmptyKind', 'llvm::Twine::NullKind'):
+      return ''
+
+    if kind == 'llvm::Twine::TwineKind':
+      return self.string_from_twine_object(child['twine'].dereference())
+
+    if kind == 'llvm::Twine::CStringKind':
+      return child['cString'].string()
+
+    if kind == 'llvm::Twine::StdStringKind':
+      val = child['stdString'].dereference()
+      return self.string_from_pretty_printer_lookup(val)
+
+    if kind == 'llvm::Twine::StringRefKind':
+      val = child['stringRef'].dereference()
+      pp = StringRefPrinter(val)
+      return pp.to_string()
+
+    if kind == 'llvm::Twine::SmallStringKind':
+      val = child['smallString'].dereference()
+      pp = SmallStringPrinter(val)
+      return pp.to_string()
+
+    if kind == 'llvm::Twine::CharKind':
+      return chr(child['character'])
+
+    if kind == 'llvm::Twine::DecUIKind':
+      return str(child['decUI'])
+
+    if kind == 'llvm::Twine::DecIKind':
+      return str(child['decI'])
+
+    if kind == 'llvm::Twine::DecULKind':
+      return str(child['decUL'].dereference())
+
+    if kind == 'llvm::Twine::DecLKind':
+      return str(child['decL'].dereference())
+
+    if kind == 'llvm::Twine::DecULLKind':
+      return str(child['decULL'].dereference())
+
+    if kind == 'llvm::Twine::DecLLKind':
+      return str(child['decLL'].dereference())
+
+    if kind == 'llvm::Twine::UHexKind':
+      val = child['uHex'].dereference()
+      return hex(int(val))
+
+    print(('Unhandled NodeKind {} in Twine pretty-printer. The result will be '
+           'incomplete.').format(kind))
+
+    return '(unhandled {})'.format(kind)
+
+  def string_from_twine_object(self, twine):
+    '''Return the string representation of the Twine object twine.'''
+
+    lhs_str = ''
+    rhs_str = ''
+
+    lhs = twine['LHS']
+    rhs = twine['RHS']
+    lhs_kind = str(twine['LHSKind'])
+    rhs_kind = str(twine['RHSKind'])
+
+    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)
 
 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::(Const)?ArrayRef<.*>$', ArrayRefPrinter)
 pp.add_printer('llvm::Optional', '^llvm::Optional<.*>$', OptionalPrinter)
 pp.add_printer('llvm::DenseMap', '^llvm::DenseMap<.*>$', DenseMapPrinter)
+pp.add_printer('llvm::Twine', '^llvm::Twine$', TwinePrinter)
 gdb.printing.register_pretty_printer(gdb.current_objfile(), pp)