1# Copyright (C) 2009-2023 Free Software Foundation, Inc. 2# 3# This file is part of GDB. 4# 5# This program is free software; you can redistribute it and/or modify 6# it under the terms of the GNU General Public License as published by 7# the Free Software Foundation; either version 3 of the License, or 8# (at your option) any later version. 9# 10# This program is distributed in the hope that it will be useful, 11# but WITHOUT ANY WARRANTY; without even the implied warranty of 12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13# GNU General Public License for more details. 14# 15# You should have received a copy of the GNU General Public License 16# along with this program. If not, see <http://www.gnu.org/licenses/>. 17 18import gdb 19import os.path 20 21 22class TypeFlag: 23 """A class that allows us to store a flag name, its short name, 24 and its value. 25 26 In the GDB sources, struct type has a component called instance_flags 27 in which the value is the addition of various flags. These flags are 28 defined by the enumerates type_instance_flag_value. This class helps us 29 recreate a list with all these flags that is easy to manipulate and sort. 30 Because all flag names start with TYPE_INSTANCE_FLAG_, a short_name 31 attribute is provided that strips this prefix. 32 33 ATTRIBUTES 34 name: The enumeration name (eg: "TYPE_INSTANCE_FLAG_CONST"). 35 value: The associated value. 36 short_name: The enumeration name, with the suffix stripped. 37 """ 38 39 def __init__(self, name, value): 40 self.name = name 41 self.value = value 42 self.short_name = name.replace("TYPE_INSTANCE_FLAG_", "") 43 44 def __lt__(self, other): 45 """Sort by value order.""" 46 return self.value < other.value 47 48 49# A list of all existing TYPE_INSTANCE_FLAGS_* enumerations, 50# stored as TypeFlags objects. Lazy-initialized. 51TYPE_FLAGS = None 52 53 54class TypeFlagsPrinter: 55 """A class that prints a decoded form of an instance_flags value. 56 57 This class uses a global named TYPE_FLAGS, which is a list of 58 all defined TypeFlag values. Using a global allows us to compute 59 this list only once. 60 61 This class relies on a couple of enumeration types being defined. 62 If not, then printing of the instance_flag is going to be degraded, 63 but it's not a fatal error. 64 """ 65 66 def __init__(self, val): 67 self.val = val 68 69 def __str__(self): 70 global TYPE_FLAGS 71 if TYPE_FLAGS is None: 72 self.init_TYPE_FLAGS() 73 if not self.val: 74 return "0" 75 if TYPE_FLAGS: 76 flag_list = [ 77 flag.short_name for flag in TYPE_FLAGS if self.val & flag.value 78 ] 79 else: 80 flag_list = ["???"] 81 return "0x%x [%s]" % (self.val, "|".join(flag_list)) 82 83 def init_TYPE_FLAGS(self): 84 """Initialize the TYPE_FLAGS global as a list of TypeFlag objects. 85 This operation requires the search of a couple of enumeration types. 86 If not found, a warning is printed on stdout, and TYPE_FLAGS is 87 set to the empty list. 88 89 The resulting list is sorted by increasing value, to facilitate 90 printing of the list of flags used in an instance_flags value. 91 """ 92 global TYPE_FLAGS 93 TYPE_FLAGS = [] 94 try: 95 iflags = gdb.lookup_type("enum type_instance_flag_value") 96 except: 97 print("Warning: Cannot find enum type_instance_flag_value type.") 98 print(" `struct type' pretty-printer will be degraded") 99 return 100 TYPE_FLAGS = [TypeFlag(field.name, field.enumval) for field in iflags.fields()] 101 TYPE_FLAGS.sort() 102 103 104class StructTypePrettyPrinter: 105 """Pretty-print an object of type struct type""" 106 107 def __init__(self, val): 108 self.val = val 109 110 def to_string(self): 111 fields = [] 112 fields.append("pointer_type = %s" % self.val["pointer_type"]) 113 fields.append("reference_type = %s" % self.val["reference_type"]) 114 fields.append("chain = %s" % self.val["reference_type"]) 115 fields.append( 116 "instance_flags = %s" % TypeFlagsPrinter(self.val["m_instance_flags"]) 117 ) 118 fields.append("length = %d" % self.val["m_length"]) 119 fields.append("main_type = %s" % self.val["main_type"]) 120 return "\n{" + ",\n ".join(fields) + "}" 121 122 123class StructMainTypePrettyPrinter: 124 """Pretty-print an objet of type main_type""" 125 126 def __init__(self, val): 127 self.val = val 128 129 def flags_to_string(self): 130 """struct main_type contains a series of components that 131 are one-bit ints whose name start with "flag_". For instance: 132 flag_unsigned, flag_stub, etc. In essence, these components are 133 really boolean flags, and this method prints a short synthetic 134 version of the value of all these flags. For instance, if 135 flag_unsigned and flag_static are the only components set to 1, 136 this function will return "unsigned|static". 137 """ 138 fields = [ 139 field.name.replace("flag_", "") 140 for field in self.val.type.fields() 141 if field.name.startswith("flag_") and self.val[field.name] 142 ] 143 return "|".join(fields) 144 145 def owner_to_string(self): 146 """Return an image of component "owner".""" 147 if self.val["m_flag_objfile_owned"] != 0: 148 return "%s (objfile)" % self.val["m_owner"]["objfile"] 149 else: 150 return "%s (gdbarch)" % self.val["m_owner"]["gdbarch"] 151 152 def struct_field_location_img(self, field_val): 153 """Return an image of the loc component inside the given field 154 gdb.Value. 155 """ 156 loc_val = field_val["m_loc"] 157 loc_kind = str(field_val["m_loc_kind"]) 158 if loc_kind == "FIELD_LOC_KIND_BITPOS": 159 return "bitpos = %d" % loc_val["bitpos"] 160 elif loc_kind == "FIELD_LOC_KIND_ENUMVAL": 161 return "enumval = %d" % loc_val["enumval"] 162 elif loc_kind == "FIELD_LOC_KIND_PHYSADDR": 163 return "physaddr = 0x%x" % loc_val["physaddr"] 164 elif loc_kind == "FIELD_LOC_KIND_PHYSNAME": 165 return "physname = %s" % loc_val["physname"] 166 elif loc_kind == "FIELD_LOC_KIND_DWARF_BLOCK": 167 return "dwarf_block = %s" % loc_val["dwarf_block"] 168 else: 169 return "m_loc = ??? (unsupported m_loc_kind value)" 170 171 def struct_field_img(self, fieldno): 172 """Return an image of the main_type field number FIELDNO.""" 173 f = self.val["flds_bnds"]["fields"][fieldno] 174 label = "flds_bnds.fields[%d]:" % fieldno 175 if f["artificial"]: 176 label += " (artificial)" 177 fields = [] 178 fields.append("m_name = %s" % f["m_name"]) 179 fields.append("m_type = %s" % f["m_type"]) 180 fields.append("m_loc_kind = %s" % f["m_loc_kind"]) 181 fields.append("bitsize = %d" % f["bitsize"]) 182 fields.append(self.struct_field_location_img(f)) 183 return label + "\n" + " {" + ",\n ".join(fields) + "}" 184 185 def bound_img(self, bound_name): 186 """Return an image of the given main_type's bound.""" 187 bounds = self.val["flds_bnds"]["bounds"].dereference() 188 b = bounds[bound_name] 189 bnd_kind = str(b["m_kind"]) 190 if bnd_kind == "PROP_CONST": 191 return str(b["m_data"]["const_val"]) 192 elif bnd_kind == "PROP_UNDEFINED": 193 return "(undefined)" 194 else: 195 info = [bnd_kind] 196 if bound_name == "high" and bounds["flag_upper_bound_is_count"]: 197 info.append("upper_bound_is_count") 198 return "{} ({})".format(str(b["m_data"]["baton"]), ",".join(info)) 199 200 def bounds_img(self): 201 """Return an image of the main_type bounds.""" 202 b = self.val["flds_bnds"]["bounds"].dereference() 203 low = self.bound_img("low") 204 high = self.bound_img("high") 205 206 img = "flds_bnds.bounds = {%s, %s}" % (low, high) 207 if b["flag_bound_evaluated"]: 208 img += " [evaluated]" 209 return img 210 211 def type_specific_img(self): 212 """Return a string image of the main_type type_specific union. 213 Only the relevant component of that union is printed (based on 214 the value of the type_specific_kind field. 215 """ 216 type_specific_kind = str(self.val["type_specific_field"]) 217 type_specific = self.val["type_specific"] 218 if type_specific_kind == "TYPE_SPECIFIC_NONE": 219 img = "type_specific_field = %s" % type_specific_kind 220 elif type_specific_kind == "TYPE_SPECIFIC_CPLUS_STUFF": 221 img = "cplus_stuff = %s" % type_specific["cplus_stuff"] 222 elif type_specific_kind == "TYPE_SPECIFIC_GNAT_STUFF": 223 img = ( 224 "gnat_stuff = {descriptive_type = %s}" 225 % type_specific["gnat_stuff"]["descriptive_type"] 226 ) 227 elif type_specific_kind == "TYPE_SPECIFIC_FLOATFORMAT": 228 img = "floatformat[0..1] = %s" % type_specific["floatformat"] 229 elif type_specific_kind == "TYPE_SPECIFIC_FUNC": 230 img = ( 231 "calling_convention = %d" 232 % type_specific["func_stuff"]["calling_convention"] 233 ) 234 # tail_call_list is not printed. 235 elif type_specific_kind == "TYPE_SPECIFIC_SELF_TYPE": 236 img = "self_type = %s" % type_specific["self_type"] 237 elif type_specific_kind == "TYPE_SPECIFIC_FIXED_POINT": 238 # The scaling factor is an opaque structure, so we cannot 239 # decode its value from Python (not without insider knowledge). 240 img = ( 241 "scaling_factor: <opaque> (call __gmpz_dump with " 242 " _mp_num and _mp_den fields if needed)" 243 ) 244 elif type_specific_kind == "TYPE_SPECIFIC_INT": 245 img = "int_stuff = { bit_size = %d, bit_offset = %d }" % ( 246 type_specific["int_stuff"]["bit_size"], 247 type_specific["int_stuff"]["bit_offset"], 248 ) 249 else: 250 img = ( 251 "type_specific = ??? (unknown type_specific_kind: %s)" 252 % type_specific_kind 253 ) 254 return img 255 256 def to_string(self): 257 """Return a pretty-printed image of our main_type.""" 258 fields = [] 259 fields.append("name = %s" % self.val["name"]) 260 fields.append("code = %s" % self.val["code"]) 261 fields.append("flags = [%s]" % self.flags_to_string()) 262 fields.append("owner = %s" % self.owner_to_string()) 263 fields.append("target_type = %s" % self.val["m_target_type"]) 264 if self.val["nfields"] > 0: 265 for fieldno in range(self.val["nfields"]): 266 fields.append(self.struct_field_img(fieldno)) 267 if self.val["code"] == gdb.TYPE_CODE_RANGE: 268 fields.append(self.bounds_img()) 269 fields.append(self.type_specific_img()) 270 271 return "\n{" + ",\n ".join(fields) + "}" 272 273 274class CoreAddrPrettyPrinter: 275 """Print CORE_ADDR values as hex.""" 276 277 def __init__(self, val): 278 self._val = val 279 280 def to_string(self): 281 return hex(int(self._val)) 282 283 284class IntrusiveListPrinter: 285 """Print a struct intrusive_list.""" 286 287 def __init__(self, val): 288 self._val = val 289 290 # Type of linked items. 291 self._item_type = self._val.type.template_argument(0) 292 self._node_ptr_type = gdb.lookup_type( 293 "intrusive_list_node<{}>".format(self._item_type.tag) 294 ).pointer() 295 296 # Type of value -> node converter. 297 self._conv_type = self._val.type.template_argument(1) 298 299 if self._uses_member_node(): 300 # The second template argument of intrusive_member_node is a member 301 # pointer value. Its value is the offset of the node member in the 302 # enclosing type. 303 member_node_ptr = self._conv_type.template_argument(1) 304 member_node_ptr = member_node_ptr.cast(gdb.lookup_type("int")) 305 self._member_node_offset = int(member_node_ptr) 306 307 # This is only needed in _as_node_ptr if using a member node. Look it 308 # up here so we only do it once. 309 self._char_ptr_type = gdb.lookup_type("char").pointer() 310 311 def display_hint(self): 312 return "array" 313 314 def _uses_member_node(self): 315 """Return True if the list items use a node as a member, False if 316 they use a node as a base class. 317 """ 318 319 if self._conv_type.name.startswith("intrusive_member_node<"): 320 return True 321 elif self._conv_type.name.startswith("intrusive_base_node<"): 322 return False 323 else: 324 raise RuntimeError( 325 "Unexpected intrusive_list value -> node converter type: {}".format( 326 self._conv_type.name 327 ) 328 ) 329 330 def to_string(self): 331 s = "intrusive list of {}".format(self._item_type) 332 333 if self._uses_member_node(): 334 node_member = self._conv_type.template_argument(1) 335 s += ", linked through {}".format(node_member) 336 337 return s 338 339 def _as_node_ptr(self, elem_ptr): 340 """Given ELEM_PTR, a pointer to a list element, return a pointer to the 341 corresponding intrusive_list_node. 342 """ 343 344 assert elem_ptr.type.code == gdb.TYPE_CODE_PTR 345 346 if self._uses_member_node(): 347 # Node as a member: add the member node offset from to the element's 348 # address to get the member node's address. 349 elem_char_ptr = elem_ptr.cast(self._char_ptr_type) 350 node_char_ptr = elem_char_ptr + self._member_node_offset 351 return node_char_ptr.cast(self._node_ptr_type) 352 else: 353 # Node as a base: just casting from node pointer to item pointer 354 # will adjust the pointer value. 355 return elem_ptr.cast(self._node_ptr_type) 356 357 def _children_generator(self): 358 """Generator that yields one tuple per list item.""" 359 360 elem_ptr = self._val["m_front"] 361 idx = 0 362 while elem_ptr != 0: 363 yield (str(idx), elem_ptr.dereference()) 364 node_ptr = self._as_node_ptr(elem_ptr) 365 elem_ptr = node_ptr["next"] 366 idx += 1 367 368 def children(self): 369 return self._children_generator() 370 371 372def type_lookup_function(val): 373 """A routine that returns the correct pretty printer for VAL 374 if appropriate. Returns None otherwise. 375 """ 376 tag = val.type.tag 377 name = val.type.name 378 if tag == "type": 379 return StructTypePrettyPrinter(val) 380 elif tag == "main_type": 381 return StructMainTypePrettyPrinter(val) 382 elif name == "CORE_ADDR": 383 return CoreAddrPrettyPrinter(val) 384 elif tag is not None and tag.startswith("intrusive_list<"): 385 return IntrusiveListPrinter(val) 386 return None 387 388 389def register_pretty_printer(objfile): 390 """A routine to register a pretty-printer against the given OBJFILE.""" 391 objfile.pretty_printers.append(type_lookup_function) 392 393 394if __name__ == "__main__": 395 if gdb.current_objfile() is not None: 396 # This is the case where this script is being "auto-loaded" 397 # for a given objfile. Register the pretty-printer for that 398 # objfile. 399 register_pretty_printer(gdb.current_objfile()) 400 else: 401 # We need to locate the objfile corresponding to the GDB 402 # executable, and register the pretty-printer for that objfile. 403 # FIXME: The condition used to match the objfile is too simplistic 404 # and will not work on Windows. 405 for objfile in gdb.objfiles(): 406 if os.path.basename(objfile.filename) == "gdb": 407 objfile.pretty_printers.append(type_lookup_function) 408