| """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) |
| else: |
| yield field.name, self.val[field.name] |
| |
| def to_string(self): |
| return "mlir::Storage" |
| |
| |
| 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] |
| |
| def to_string(self): |
| return "mlir::TupleTypeStorage of %u elements" % self.val["numElements"] |
| |
| |
| 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] |
| |
| def to_string(self): |
| return "mlir::FusedLocationStorage of %u locs" % self.val["numLocs"] |
| |
| |
| class StorageTypeMap: |
| """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 = [] |
| |
| def register_type(self, type_name): |
| assert not self.map, "register_type called after __getitem__" |
| self.type_names += [type_name] |
| |
| def _init_map(self): |
| """Lazy initialization of self.map.""" |
| if self.map: |
| return |
| self.map = {} |
| for type_name in self.type_names: |
| concrete_type = gdb.lookup_type(type_name) |
| try: |
| storage = gdb.parse_and_eval( |
| "&'mlir::detail::TypeIDExported::get<%s>()::instance'" % type_name |
| ) |
| except gdb.error: |
| # Skip when TypeID instance cannot be found in current context. |
| continue |
| if concrete_type and storage: |
| self.map[int(storage)] = concrete_type |
| |
| def __getitem__(self, type_id): |
| self._init_map() |
| return self.map.get(int(type_id["storage"])) |
| |
| |
| storage_type_map = StorageTypeMap() |
| |
| |
| def get_type_id_printer(val): |
| """Returns a printer of the name of a mlir::TypeID.""" |
| |
| 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 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 AttrOrTypePrinter: |
| def __init__(self, type_id, impl): |
| self.type_id = type_id |
| self.impl = impl |
| |
| def children(self): |
| yield "typeID", self.type_id |
| yield "impl", self.impl |
| |
| def to_string(self): |
| return "cast<%s>" % self.impl.type |
| |
| if not val["impl"]: |
| return None |
| impl = val["impl"].dereference() |
| type_id = get_type_id(impl) |
| concrete_type = storage_type_map[type_id] |
| if not concrete_type: |
| return None |
| # 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)) |
| |
| |
| class ImplPrinter: |
| """Printer for an instance with a single 'impl' member pointer.""" |
| |
| def __init__(self, val): |
| self.val = val |
| self.impl = val["impl"] |
| |
| def children(self): |
| if self.impl: |
| yield "impl", self.impl.dereference() |
| |
| def to_string(self): |
| return self.val.type.name |
| |
| |
| # Printers of types deriving from Attribute::AttrBase or Type::TypeBase. |
| for name in [ |
| # mlir/IR/Attributes.h |
| "ArrayAttr", |
| "DictionaryAttr", |
| "FloatAttr", |
| "IntegerAttr", |
| "IntegerSetAttr", |
| "OpaqueAttr", |
| "StringAttr", |
| "SymbolRefAttr", |
| "TypeAttr", |
| "UnitAttr", |
| "DenseStringElementsAttr", |
| "DenseIntOrFPElementsAttr", |
| "SparseElementsAttr", |
| # mlir/IR/BuiltinTypes.h |
| "ComplexType", |
| "IndexType", |
| "IntegerType", |
| "Float16Type", |
| "FloatTF32Type", |
| "Float32Type", |
| "Float64Type", |
| "Float80Type", |
| "Float128Type", |
| "NoneType", |
| "VectorType", |
| "RankedTensorType", |
| "UnrankedTensorType", |
| "MemRefType", |
| "UnrankedMemRefType", |
| "TupleType", |
| # mlir/IR/Location.h |
| "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), |
| ) |
| |
| |
| # 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) |
