Update mlir GDB printers

[csigg]

Summary

Update prettyprinters.py to match MLIR changes.

This has gone unnoticed because no build bot is running tests with debug info.

I will look into what we can do about this separately. There is
https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/,
from Apple. The Debug Info tests are failing despite the green result.

See https://github.com/llvm/llvm-project/issues/48872.

Note: the llvm-support.gdb test only works with Debug,
but not RelWithDebInfo because some checked symbols are stripped.

[dblaikie]

I don't have a very high bar for this - if you're the only one currently using/interested in the MLIR GDB pretty printers, should probably feel free to commit changes without review. I don't have enough context for MLIR to offer any nuanced review - just some general/relatively uninformed ideas about general code/test style, etc. (welcome to send them for review & I can provide that if it's useful to you, though)

cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.gdb

25–28

while you're refactoring this file anyway, might it make sense to put the actual command before the CHECKs? More like the way assertions are done in a gunit test, etc? (that way the reader isn't looking ahead to see what command is being run to figure out why these CHECKs are the right ones)

40–43

Is this all the output? Is it on one line or multiple, is there any punctuation separating the fields/values?

Might be worth using CHECK-SAME or CHECK-NEXT depending on whether it's on one line or multiple, and if there's other punctuation, etc, I think I'd prefer to see that in the check to make it clear how this renders to a user. (because, at least to me/as it stands, it seems a bit ad-hoc - I'm not sure I'd know how to read that output/what to make of it - at least maybe I'd expect each part to have a "x = y" form, maybe)

Similarly for some of the other type dumps here.

[csigg]

Move CHECK statements after print.

[csigg]

Thanks David for the review, I appreciate your input.

cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.gdb

25–28

Yes, that makes sense. Thanks for the suggestion.

40–43

This change adds set pretty print on, which makes gdb print on multiple lines. The CHECKs also work with off (single-line print outputs), but failures become harder to read. The CHECK-LABELs guarantee that all CHECKs apply to a single print statement.

Is this all the output?

No, the output is much much larger than this. The pretty printers here do no try to trim the output, but rather show more information (e.g., print the mlir::Value::impl pointee as well). See the attached file.

The CHECKs only verify that the essential information is in the output, and are not intended to "make it clear how this renders to a user". I think doing so would make the test quite brittle wrt to mlir code changes.

mlir-support.log42 KBDownload

[dblaikie]

cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.gdb

40–43

Ah, thanks for the context! I see, so in this case as an example (UnrankedMemRef) it prints the typeID, then it casts down to the concrete type and returns that back for gdb generic pretty printing? (hmm, actually I guess that isn't generic printing - the "members of" isn't how gdb is printing some simple examples of derived classes I'm looking at, for instance)

I'd probably add a bit more structure to the checks myself, even if it's not every line of output. (like I'd probably test the whole "typeID = " line, so this wouldn't match some other mention of UnrankedMemRefType in the rest of the output, possibly - which could make for hard to diagnose FileCheck failures in the future - possibly using CHECK-NEXT, again, to constrain the expectation a bit. Beyond that, if the rest of that is using some generic pretty printing functionality - yeah, maybe there's not much to it & checking some members you know are unique to the downcasted type is about right. Maybe just looking for the "members of type " line would be adequate, then)

But no worries - whatever you find works best for you in this case I expect will be OK.

cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.gdb

-# RUN: gdb -q -batch -n -iex 'source %mlir_src_root/utils/gdb-scripts/prettyprinters.py' -iex 'source %llvm_src_root/utils/gdb-scripts/prettyprinters.py' -x %s %llvm_tools_dir/check-gdb-mlir-support | FileCheck %s
+# RUN: gdb -q -batch -n \
+# RUN:   -iex 'source %mlir_src_root/utils/gdb-scripts/prettyprinters.py' \
+# RUN:   -iex 'source %llvm_src_root/utils/gdb-scripts/prettyprinters.py' \
+# RUN:   -ex 'source -v %s' %llvm_tools_dir/check-gdb-mlir-support \
+# RUN: | FileCheck %s
 # REQUIRES: debug-info
 # REQUIRES: mlir
 
 break main
 run
+set print pretty on
 
+# CHECK-LABEL: +print Identifier
 # CHECK: "foo"
-p Identifier
+print Identifier
 
+# CHECK-LABEL: +print OperationName
 # CHECK: "FooOp"
-p OperationName
-
-# CHECK: 0x8
-# CHECK: TrailingOpResult
-p Value
+print OperationName
 
+# CHECK-LABEL: +print Type
 # CHECK: impl = 0x0
-p Type
+print Type
 
-# CHECK: cast<mlir::IndexType>
-p IndexType
+# CHECK-LABEL: +print IndexType
+# CHECK: mlir::IndexType
+print IndexType
 
-# CHECK: cast<mlir::IntegerType>
+# CHECK-LABEL: +print IntegerType
+# CHECK: mlir::IntegerType
 # CHECK: width = 3
 # CHECK: Unsigned
-p IntegerType
+print IntegerType
+
+# CHECK-LABEL: +print FloatType
+# CHECK: mlir::Float32Type
+print FloatType
 
-# CHECK: cast<mlir::Float32Type>
-p FloatType
+# CHECK-LABEL: +print MemRefType
+# CHECK: mlir::MemRefType
+# CHECK: shape = llvm::ArrayRef of length 2 = {4, 5}
+# CHECK: elementType
+# CHECK: mlir::Float32Type
+print MemRefType
 
-# CHECK: cast<mlir::MemRefType>
-# CHECK: shapeSize = 2
-# CHECK: shapeElements[0] = 4
-# CHECK: shapeElements[1] = 5
-p MemRefType
-
-# CHECK: cast<mlir::UnrankedMemRefType>
-# CHECK: memorySpace = 6
-p UnrankedMemRefType
-
-# CHECK: cast<mlir::VectorType>
-# CHECK: shapeSize = 2
-# CHECK: shapeElements[0] = 1
-# CHECK: shapeElements[1] = 2
-p VectorType
+# CHECK-LABEL: +print UnrankedMemRefType
+# CHECK: mlir::UnrankedMemRefType
+# CHECK: elementType
+# CHECK: mlir::IntegerType
+# CHECK: memorySpace
+# CHECK: 6
+print UnrankedMemRefType
+
+# CHECK-LABEL: +print VectorType
+# CHECK: mlir::VectorType
+# CHECK: shape = llvm::ArrayRef of length 2 = {1, 2}
+print VectorType
 
-# CHECK: cast<mlir::TupleType>
+# CHECK-LABEL: +print TupleType
+# CHECK: mlir::TupleType
 # CHECK: numElements = 2
 # CHECK: elements[0]
 # CHECK: mlir::IndexType
 # CHECK: elements[1]
 # CHECK: mlir::Float32Type
-p TupleType
+print TupleType
+
+# CHECK-LABEL: +print Result
+# CHECK: mlir::Float32Type
+# CHECK: outOfLineIndex = 42
+print Result
 
-# CHECK: cast<mlir::UnknownLoc>
-p UnknownLoc
+# CHECK-LABEL: +print Value
+# CHECK: OutOfLineOpResult
+print Value
 
-# CHECK: cast<mlir::FileLineColLoc>
-# CHECK: filename = "file"
+# CHECK-LABEL: +print UnknownLoc
+# CHECK: mlir::UnknownLoc
+print UnknownLoc
+
+# CHECK-LABEL: +print FileLineColLoc
+# CHECK: mlir::FileLineColLoc
+# CHECK: "file"
 # CHECK: line = 7
 # CHECK: column = 8
-p FileLineColLoc
+print FileLineColLoc
 
-# CHECK: cast<mlir::OpaqueLoc>
+# CHECK-LABEL: +print OpaqueLoc
+# CHECK: mlir::OpaqueLoc
 # CHECK: underlyingLocation = 9
-p OpaqueLoc
+print OpaqueLoc
 
-# CHECK: cast<mlir::NameLoc>
-# CHECK: name = "foo"
+# CHECK-LABEL: +print NameLoc
+# CHECK: mlir::NameLoc
+# CHECK: "foo"
 # CHECK: mlir::UnknownLoc
-p NameLoc
+print NameLoc
 
-# CHECK: cast<mlir::CallSiteLoc>
+# CHECK-LABEL: +print CallSiteLoc
+# CHECK: mlir::CallSiteLoc
 # CHECK: callee
 # CHECK: mlir::FileLineColLoc
 # CHECK: caller
 # CHECK: mlir::OpaqueLoc
-p CallSiteLoc
+print CallSiteLoc
 
-# CHECK: cast<mlir::FusedLoc>
-# CHECK: numLocs = 2
-# CHECK: locs[0]
+# CHECK-LABEL: +print FusedLoc
+# CHECK: mlir::FusedLoc
+# CHECK: locations = llvm::ArrayRef of length 2
 # CHECK: mlir::FileLineColLoc
-# CHECK: locs[1]
 # CHECK: mlir::NameLoc
-p FusedLoc
-
-# CHECK: cast<mlir::UnitAttr>
-p UnitAttr
+print FusedLoc
 
-# CHECK: cast<mlir::FloatAttr>
-p FloatAttr
+# CHECK-LABEL: +print UnitAttr
+# CHECK: mlir::UnitAttr
+print UnitAttr
 
-# CHECK: cast<mlir::IntegerAttr>
-p IntegerAttr
+# CHECK-LABEL: +print FloatAttr
+# CHECK: mlir::FloatAttr
+print FloatAttr
+
+# CHECK-LABEL: +print IntegerAttr
+# CHECK: mlir::IntegerAttr
+print IntegerAttr
 
-# CHECK: cast<mlir::TypeAttr>
+# CHECK-LABEL: +print TypeAttr
+# CHECK: mlir::TypeAttr
 # CHECK: mlir::IndexType
-p TypeAttr
+print TypeAttr
 
-# CHECK: cast<mlir::ArrayAttr>
+# CHECK-LABEL: +print ArrayAttr
+# CHECK: mlir::ArrayAttr
 # CHECK: llvm::ArrayRef of length 1
 # CHECK: mlir::UnitAttr
-p ArrayAttr
+print ArrayAttr
 
-# CHECK: cast<mlir::StringAttr>
+# CHECK-LABEL: +print StringAttr
+# CHECK: mlir::StringAttr
 # CHECK: value = "foo"
-p StringAttr
+print StringAttr
 
-# CHECK: cast<mlir::DenseIntOrFPElementsAttr>
-p ElementsAttr
+# CHECK-LABEL: +print ElementsAttr
+# CHECK: mlir::DenseIntOrFPElementsAttr
+print ElementsAttr

mlir/utils/gdb-scripts/prettyprinters.py

 """GDB pretty printers for MLIR types."""
 
 import gdb.printing
 
 
 class StoragePrinter:
   """Prints bases of a struct and its fields."""
 
   def __init__(self, val):
     self.val = val
 
   def children(self):
     for field in self.val.type.fields():
       if field.is_base_class:
-        yield ('<%s>' % field.name, self.val.cast(field.type))
+        yield '<%s>' % field.name, self.val.cast(field.type)
       else:
-        yield (field.name, self.val[field.name])
+        yield field.name, self.val[field.name]
 
 
 class TupleTypeStoragePrinter(StoragePrinter):
 
   def children(self):
     for child in StoragePrinter.children(self):
       yield child
     pointer_type = gdb.lookup_type('mlir::Type').pointer()
     elements = (self.val.address + 1).cast(pointer_type)
     for i in range(self.val['numElements']):
       yield 'elements[%u]' % i, elements[i]
 
 
-class RankedTypeStoragePrinter(StoragePrinter):
-
-  def children(self):
-    for child in StoragePrinter.children(self):
-      yield child
-    for i in range(self.val['shapeSize']):
-      yield 'shapeElements[%u]' % i, self.val['shapeElements'][i]
-
-
-class MemRefTypeStoragePrinter(RankedTypeStoragePrinter):
-
-  def children(self):
-    for child in RankedTypeStoragePrinter.children(self):
-      yield child
-    for i in range(self.val['numAffineMaps']):
-      yield 'affineMapsList[%u]' % i, self.val['affineMapsList'][i]
-
-
 class FusedLocationStoragePrinter(StoragePrinter):
 
   def children(self):
     for child in StoragePrinter.children(self):
       yield child
     pointer_type = gdb.lookup_type('mlir::Location').pointer()
     elements = (self.val.address + 1).cast(pointer_type)
     for i in range(self.val['numLocs']):
       yield 'locs[%u]' % i, elements[i]
 
 
-class StorageUserBasePrinter:
-  """Printer for an mlir::detail::StorageUserBase instance."""
-
-  def __init__(self, val):
-    self.val = val
-
-  def children(self):
-    storage_type = self.val.type.template_argument(2)
-    yield 'impl', self.val['impl'].dereference().cast(storage_type)
-
-
 class StorageTypeMap:
-  """Maps a TypeID to the corresponding type derived from StorageUserBase.
+  """Maps a TypeID to the corresponding concrete type.
 
   Types need to be registered by name before the first lookup.
   """
 
   def __init__(self):
     self.map = None
     self.type_names = []
 

 
 
 storage_type_map = StorageTypeMap()
 
 
 def get_type_id_printer(val):
   """Returns a printer of the name of a mlir::TypeID."""
 
-  class StringPrinter:
+  class TypeIdPrinter:
 
     def __init__(self, string):
       self.string = string
 
     def to_string(self):
       return self.string
 
   concrete_type = storage_type_map[val]
   if not concrete_type:
     return None
-  return StringPrinter('"%s"' % concrete_type.name)
+  return TypeIdPrinter('mlir::TypeID::get<%s>()' % concrete_type)
 
 
 def get_attr_or_type_printer(val, get_type_id):
   """Returns a printer for mlir::Attribute or mlir::Type."""
 
-  class UpcastPrinter:
+  class AttrOrTypePrinter:
 
-    def __init__(self, val, type):
-      self.val = val.cast(type)
+    def __init__(self, type_id, impl):
+      self.type_id = type_id
+      self.impl = impl
 
     def children(self):
-      yield 'cast<%s>' % self.val.type.name, self.val
+      yield 'typeID', self.type_id
+      yield 'cast<%s>(impl)' % self.impl.type, self.impl
 
   if not val['impl']:
     return None
-  type_id = get_type_id(val['impl'].dereference())
+  impl = val['impl'].dereference()
+  type_id = get_type_id(impl)
   concrete_type = storage_type_map[type_id]
   if not concrete_type:
     return None
-  return UpcastPrinter(val, concrete_type)
+  # 3rd template argument of StorageUserBase is the storage type.
+  storage_type = concrete_type.fields()[0].type.template_argument(2)
+  if not storage_type:
+    return None
+  return AttrOrTypePrinter(type_id, impl.cast(storage_type))
 
 
-pp = gdb.printing.RegexpCollectionPrettyPrinter('MLIRSupport')
+class ImplPrinter:
+  """Printer for an instance with a single 'impl' member pointer."""
 
-# Printers for types deriving from AttributeStorage or TypeStorage.
-pp.add_printer('mlir::detail::FusedLocationStorage',
-               '^mlir::detail::FusedLocationStorage',
-               FusedLocationStoragePrinter)
-pp.add_printer('mlir::detail::VectorTypeStorage',
-               '^mlir::detail::VectorTypeStorage', RankedTypeStoragePrinter)
-pp.add_printer('mlir::detail::RankedTensorTypeStorage',
-               '^mlir::detail::RankedTensorTypeStorage',
-               RankedTypeStoragePrinter)
-pp.add_printer('mlir::detail::MemRefTypeStorage',
-               '^mlir::detail::MemRefTypeStorage$', MemRefTypeStoragePrinter)
-pp.add_printer('mlir::detail::TupleTypeStorage',
-               '^mlir::detail::TupleTypeStorage$', TupleTypeStoragePrinter)
+  def __init__(self, val):
+    self.impl = val['impl']
+
+  def children(self):
+    yield 'impl', (self.impl.dereference() if self.impl else self.impl)
 
-# Printers for Attribute::AttrBase or Type::TypeBase typedefs.
-pp.add_printer('mlir::detail::StorageUserBase',
-               '^mlir::detail::StorageUserBase<.*>$', StorageUserBasePrinter)
 
 # Printers of types deriving from Attribute::AttrBase or Type::TypeBase.
 for name in [
     # mlir/IR/Attributes.h
     'ArrayAttr',
     'DictionaryAttr',
     'FloatAttr',
     'IntegerAttr',
for name in [
     'CallSiteLoc',
     'FileLineColLoc',
     'FusedLoc',
     'NameLoc',
     'OpaqueLoc',
     'UnknownLoc'
 ]:
   storage_type_map.register_type('mlir::%s' % name)  # Register for upcasting.
+storage_type_map.register_type('void')  # Register default.
+
+
+pp = gdb.printing.RegexpCollectionPrettyPrinter('MLIRSupport')
+
+pp.add_printer('mlir::OperationName', '^mlir::OperationName$', ImplPrinter)
+pp.add_printer('mlir::Value', '^mlir::Value$', ImplPrinter)
+
+# Printers for types deriving from AttributeStorage or TypeStorage.
+pp.add_printer('mlir::detail::FusedLocationStorage',
+               '^mlir::detail::FusedLocationStorage',
+               FusedLocationStoragePrinter)
+pp.add_printer('mlir::detail::TupleTypeStorage',
+               '^mlir::detail::TupleTypeStorage$', TupleTypeStoragePrinter)
 
 pp.add_printer('mlir::TypeID', '^mlir::TypeID$', get_type_id_printer)
 
 
 def add_attr_or_type_printers(name):
   """Adds printers for mlir::Attribute or mlir::Type and their Storage type."""
   get_type_id = lambda val: val['abstract%s' % name]['typeID']
   pp.add_printer('mlir::%s' % name, '^mlir::%s$' % name,
                  lambda val: get_attr_or_type_printer(val, get_type_id))
-  pp.add_printer('mlir::%sStorage' % name, '^mlir::%sStorage$' % name,
-                 lambda val: get_type_id_printer(get_type_id(val)))
 
 
 # Upcasting printers of mlir::Attribute and mlir::Type.
 for name in ['Attribute', 'Type']:
   add_attr_or_type_printers(name)
 
 gdb.printing.register_pretty_printer(gdb.current_objfile(), pp)