1# Copyright (C) 2008-2023 Free Software Foundation, Inc. 2 3# This program is free software; you can redistribute it and/or modify 4# it under the terms of the GNU General Public License as published by 5# the Free Software Foundation; either version 3 of the License, or 6# (at your option) any later version. 7# 8# This program is distributed in the hope that it will be useful, 9# but WITHOUT ANY WARRANTY; without even the implied warranty of 10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11# GNU General Public License for more details. 12# 13# You should have received a copy of the GNU General Public License 14# along with this program. If not, see <http://www.gnu.org/licenses/>. 15 16# This file is part of the GDB testsuite. It tests python pretty 17# printers. 18 19import re 20import gdb 21 22 23def _iterator(pointer, len): 24 start = pointer 25 end = pointer + len 26 while pointer != end: 27 yield ("[%d]" % int(pointer - start), pointer.dereference()) 28 pointer += 1 29 30 31# Same as _iterator but can be told to raise an exception. 32def _iterator_except(pointer, len): 33 start = pointer 34 end = pointer + len 35 while pointer != end: 36 if exception_flag: 37 raise gdb.MemoryError("hi bob") 38 yield ("[%d]" % int(pointer - start), pointer.dereference()) 39 pointer += 1 40 41 42# Test returning a Value from a printer. 43class string_print(object): 44 def __init__(self, val): 45 self.val = val 46 47 def to_string(self): 48 return self.val["whybother"]["contents"] 49 50 51# Test a class-based printer. 52class ContainerPrinter(object): 53 def __init__(self, val): 54 self.val = val 55 56 def to_string(self): 57 return "container %s with %d elements" % (self.val["name"], self.val["len"]) 58 59 def children(self): 60 return _iterator(self.val["elements"], self.val["len"]) 61 62 def display_hint(self): 63 if self.val["is_map_p"] and self.val["is_array_p"]: 64 raise Exception("invalid object state found in display_hint") 65 66 if self.val["is_map_p"]: 67 return "map" 68 elif self.val["is_array_p"]: 69 return "array" 70 else: 71 return None 72 73 74# Treats a container as array. 75class ArrayPrinter(object): 76 def __init__(self, val): 77 self.val = val 78 79 def to_string(self): 80 return "array %s with %d elements" % (self.val["name"], self.val["len"]) 81 82 def children(self): 83 return _iterator(self.val["elements"], self.val["len"]) 84 85 def display_hint(self): 86 return "array" 87 88 89# Flag to make NoStringContainerPrinter throw an exception. 90exception_flag = False 91 92# Test a printer where to_string is None 93class NoStringContainerPrinter(object): 94 def __init__(self, val): 95 self.val = val 96 97 def to_string(self): 98 return None 99 100 def children(self): 101 return _iterator_except(self.val["elements"], self.val["len"]) 102 103 104# See ToStringReturnsValueWrapper. 105class ToStringReturnsValueInner: 106 def __init__(self, val): 107 self.val = val 108 109 def to_string(self): 110 return "Inner to_string {}".format(int(self.val["val"])) 111 112 113# Test a printer that returns a gdb.Value in its to_string. That gdb.Value 114# also has its own pretty-printer. 115class ToStringReturnsValueWrapper: 116 def __init__(self, val): 117 self.val = val 118 119 def to_string(self): 120 return self.val["inner"] 121 122 123class pp_s(object): 124 def __init__(self, val): 125 self.val = val 126 127 def to_string(self): 128 a = self.val["a"] 129 b = self.val["b"] 130 if a.address != b: 131 raise Exception("&a(%s) != b(%s)" % (str(a.address), str(b))) 132 return " a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">" 133 134 135class pp_ss(object): 136 def __init__(self, val): 137 self.val = val 138 139 def to_string(self): 140 return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">" 141 142 143class pp_sss(object): 144 def __init__(self, val): 145 self.val = val 146 147 def to_string(self): 148 return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">" 149 150 151class pp_multiple_virtual(object): 152 def __init__(self, val): 153 self.val = val 154 155 def to_string(self): 156 return "pp value variable is: " + str(self.val["value"]) 157 158 159class pp_vbase1(object): 160 def __init__(self, val): 161 self.val = val 162 163 def to_string(self): 164 return "pp class name: " + self.val.type.tag 165 166 167class pp_nullstr(object): 168 def __init__(self, val): 169 self.val = val 170 171 def to_string(self): 172 return self.val["s"].string(gdb.target_charset()) 173 174 175class pp_ns(object): 176 "Print a std::basic_string of some kind" 177 178 def __init__(self, val): 179 self.val = val 180 181 def to_string(self): 182 len = self.val["length"] 183 return self.val["null_str"].string(gdb.target_charset(), length=len) 184 185 def display_hint(self): 186 return "string" 187 188 189pp_ls_encoding = None 190 191 192class pp_ls(object): 193 "Print a std::basic_string of some kind" 194 195 def __init__(self, val): 196 self.val = val 197 198 def to_string(self): 199 length = self.val["len"] 200 if pp_ls_encoding is not None: 201 if length >= 0: 202 return self.val["lazy_str"].lazy_string( 203 encoding=pp_ls_encoding, length=length 204 ) 205 else: 206 return self.val["lazy_str"].lazy_string(encoding=pp_ls_encoding) 207 else: 208 if length >= 0: 209 return self.val["lazy_str"].lazy_string(length=length) 210 else: 211 return self.val["lazy_str"].lazy_string() 212 213 def display_hint(self): 214 return "string" 215 216 217class pp_hint_error(object): 218 "Throw error from display_hint" 219 220 def __init__(self, val): 221 self.val = val 222 223 def to_string(self): 224 return "hint_error_val" 225 226 def display_hint(self): 227 raise Exception("hint failed") 228 229 230class pp_children_as_list(object): 231 "Throw error from display_hint" 232 233 def __init__(self, val): 234 self.val = val 235 236 def to_string(self): 237 return "children_as_list_val" 238 239 def children(self): 240 return [("one", 1)] 241 242 243class pp_outer(object): 244 "Print struct outer" 245 246 def __init__(self, val): 247 self.val = val 248 249 def to_string(self): 250 return "x = %s" % self.val["x"] 251 252 def children(self): 253 yield "s", self.val["s"] 254 yield "x", self.val["x"] 255 256 257class MemoryErrorString(object): 258 "Raise an error" 259 260 def __init__(self, val): 261 self.val = val 262 263 def to_string(self): 264 raise gdb.MemoryError("Cannot access memory.") 265 266 def display_hint(self): 267 return "string" 268 269 270class pp_eval_type(object): 271 def __init__(self, val): 272 self.val = val 273 274 def to_string(self): 275 gdb.execute("bt", to_string=True) 276 return ( 277 "eval=<" 278 + str(gdb.parse_and_eval("eval_func (123456789, 2, 3, 4, 5, 6, 7, 8)")) 279 + ">" 280 ) 281 282 283class pp_int_typedef(object): 284 def __init__(self, val): 285 self.val = val 286 287 def to_string(self): 288 return "type=%s, val=%s" % (self.val.type, int(self.val)) 289 290 291class pp_int_typedef3(object): 292 "A printer without a to_string method" 293 294 def __init__(self, val): 295 self.val = val 296 297 def children(self): 298 yield "s", 27 299 300 301def lookup_function(val): 302 "Look-up and return a pretty-printer that can print val." 303 304 # Get the type. 305 type = val.type 306 307 # If it points to a reference, get the reference. 308 if type.code == gdb.TYPE_CODE_REF: 309 type = type.target() 310 311 # Get the unqualified type, stripped of typedefs. 312 type = type.unqualified().strip_typedefs() 313 314 # Get the type name. 315 typename = type.tag 316 317 if typename is None: 318 return None 319 320 # Iterate over local dictionary of types to determine 321 # if a printer is registered for that type. Return an 322 # instantiation of the printer if found. 323 for function in pretty_printers_dict: 324 if function.match(typename): 325 return pretty_printers_dict[function](val) 326 327 # Cannot find a pretty printer. Return None. 328 329 return None 330 331 332def disable_lookup_function(): 333 lookup_function.enabled = False 334 335 336def enable_lookup_function(): 337 lookup_function.enabled = True 338 339 340# Lookup a printer for VAL in the typedefs dict. 341def lookup_typedefs_function(val): 342 "Look-up and return a pretty-printer that can print val (typedefs)." 343 344 # Get the type. 345 type = val.type 346 347 if type is None or type.name is None or type.code != gdb.TYPE_CODE_TYPEDEF: 348 return None 349 350 # Iterate over local dictionary of typedef types to determine if a 351 # printer is registered for that type. Return an instantiation of 352 # the printer if found. 353 for function in typedefs_pretty_printers_dict: 354 if function.match(type.name): 355 return typedefs_pretty_printers_dict[function](val) 356 357 # Cannot find a pretty printer. 358 return None 359 360 361def register_pretty_printers(): 362 pretty_printers_dict[re.compile("^struct s$")] = pp_s 363 pretty_printers_dict[re.compile("^s$")] = pp_s 364 pretty_printers_dict[re.compile("^S$")] = pp_s 365 366 pretty_printers_dict[re.compile("^struct ss$")] = pp_ss 367 pretty_printers_dict[re.compile("^ss$")] = pp_ss 368 pretty_printers_dict[re.compile("^const S &$")] = pp_s 369 pretty_printers_dict[re.compile("^SSS$")] = pp_sss 370 371 pretty_printers_dict[re.compile("^VirtualTest$")] = pp_multiple_virtual 372 pretty_printers_dict[re.compile("^Vbase1$")] = pp_vbase1 373 374 pretty_printers_dict[re.compile("^struct nullstr$")] = pp_nullstr 375 pretty_printers_dict[re.compile("^nullstr$")] = pp_nullstr 376 377 # Note that we purposely omit the typedef names here. 378 # Printer lookup is based on canonical name. 379 # However, we do need both tagged and untagged variants, to handle 380 # both the C and C++ cases. 381 pretty_printers_dict[re.compile("^struct string_repr$")] = string_print 382 pretty_printers_dict[re.compile("^struct container$")] = ContainerPrinter 383 pretty_printers_dict[re.compile("^struct justchildren$")] = NoStringContainerPrinter 384 pretty_printers_dict[re.compile("^string_repr$")] = string_print 385 pretty_printers_dict[re.compile("^container$")] = ContainerPrinter 386 pretty_printers_dict[re.compile("^justchildren$")] = NoStringContainerPrinter 387 388 pretty_printers_dict[ 389 re.compile("^struct to_string_returns_value_inner$") 390 ] = ToStringReturnsValueInner 391 pretty_printers_dict[ 392 re.compile("^to_string_returns_value_inner$") 393 ] = ToStringReturnsValueInner 394 pretty_printers_dict[ 395 re.compile("^struct to_string_returns_value_wrapper$") 396 ] = ToStringReturnsValueWrapper 397 pretty_printers_dict[ 398 re.compile("^to_string_returns_value_wrapper$") 399 ] = ToStringReturnsValueWrapper 400 401 pretty_printers_dict[re.compile("^struct ns$")] = pp_ns 402 pretty_printers_dict[re.compile("^ns$")] = pp_ns 403 404 pretty_printers_dict[re.compile("^struct lazystring$")] = pp_ls 405 pretty_printers_dict[re.compile("^lazystring$")] = pp_ls 406 407 pretty_printers_dict[re.compile("^struct outerstruct$")] = pp_outer 408 pretty_printers_dict[re.compile("^outerstruct$")] = pp_outer 409 410 pretty_printers_dict[re.compile("^struct hint_error$")] = pp_hint_error 411 pretty_printers_dict[re.compile("^hint_error$")] = pp_hint_error 412 413 pretty_printers_dict[re.compile("^struct children_as_list$")] = pp_children_as_list 414 pretty_printers_dict[re.compile("^children_as_list$")] = pp_children_as_list 415 416 pretty_printers_dict[re.compile("^memory_error$")] = MemoryErrorString 417 418 pretty_printers_dict[re.compile("^eval_type_s$")] = pp_eval_type 419 420 typedefs_pretty_printers_dict[re.compile("^int_type$")] = pp_int_typedef 421 typedefs_pretty_printers_dict[re.compile("^int_type2$")] = pp_int_typedef 422 typedefs_pretty_printers_dict[re.compile("^int_type3$")] = pp_int_typedef3 423 424 425# Dict for struct types with typedefs fully stripped. 426pretty_printers_dict = {} 427# Dict for typedef types. 428typedefs_pretty_printers_dict = {} 429 430register_pretty_printers() 431gdb.pretty_printers.append(lookup_function) 432gdb.pretty_printers.append(lookup_typedefs_function) 433