1# This test code is part of GDB, the GNU debugger. 2 3# Copyright 2003-2015 Free Software Foundation, Inc. 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 18# Auxiliary function to check for known problems. 19# 20# EXPECTED_STRING is the string expected by the test. 21# 22# ACTUAL_STRING is the actual string output by gdb. 23# 24# ERRATA_TABLE is a list of lines of the form: 25# 26# { expected-string broken-string {eval-block} } 27# 28# If there is a line for the given EXPECTED_STRING, and if the 29# ACTUAL_STRING output by gdb is the same as the BROKEN_STRING in the 30# table, then I eval the eval-block. 31 32proc cp_check_errata { expected_string actual_string errata_table } { 33 foreach erratum $errata_table { 34 if { "$expected_string" == [lindex $erratum 0] 35 && "$actual_string" == [lindex $erratum 1] } then { 36 eval [lindex $erratum 2] 37 } 38 } 39} 40 41# Test ptype of a class. 42# 43# Different C++ compilers produce different output. To accommodate all 44# the variations listed below, I read the output of "ptype" and process 45# each line, matching it to the class description given in the 46# parameters. 47# 48# IN_EXP is the expression to use; the appropriate "ptype" invocation 49# is prepended to it. IN_TESTNAME is the testname for 50# gdb_test_multiple. If IN_TESTNAME is the empty string, then it 51# defaults to "ptype IN_EXP". 52# 53# IN_KEY is "class" or "struct". For now, I ignore it, and allow either 54# "class" or "struct" in the output, as long as the access specifiers all 55# work out okay. 56# 57# IN_TAG is the class tag or structure tag. 58# 59# IN_CLASS_TABLE is a list of class information. Each entry contains a 60# keyword and some values. The keywords and their values are: 61# 62# { base "base-declaration" } 63# 64# the class has a base with the given declaration. 65# 66# { vbase "name" } 67# 68# the class has a virtual base pointer with the given name. this 69# is for gcc 2.95.3, which emits ptype entries for the virtual base 70# pointers. the vbase list includes both indirect and direct 71# virtual base classes (indeed, a virtual base is usually 72# indirect), so this information cannot be derived from the base 73# declarations. 74# 75# { field "access" "declaration" } 76# 77# the class has a data field with the given access type and the 78# given declaration. 79# 80# { method "access" "declaration" } 81# 82# the class has a member function with the given access type 83# and the given declaration. 84# 85# { typedef "access" "declaration" } 86# 87# the class has a typedef with the given access type and the 88# given declaration. 89# 90# If you test the same class declaration more than once, you can specify 91# IN_CLASS_TABLE as "ibid". "ibid" means: look for a previous class 92# table that had the same IN_KEY and IN_TAG, and re-use that table. 93# 94# IN_TAIL is the expected text after the close brace, specifically the "*" 95# in "struct { ... } *". This is an optional parameter. The default 96# value is "", for no tail. 97# 98# IN_ERRATA_TABLE is a list of errata entries. See cp_check_errata for the 99# format of the errata table. Note: the errata entries are not subject to 100# demangler syntax adjustment, so you have to make a bigger table 101# with lines for each output variation. 102# 103# IN_PTYPE_ARG are arguments to pass to ptype. The default is "/r". 104# 105# gdb can vary the output of ptype in several ways: 106# 107# . CLASS/STRUCT 108# 109# The output can start with either "class" or "struct", depending on 110# what the symbol table reader in gdb decides. This is usually 111# unrelated to the original source code. 112# 113# dwarf-2 debug info distinguishes class/struct, but gdb ignores it 114# stabs+ debug info does not distinguish class/struct 115# hp debug info distinguishes class/struct, and gdb honors it 116# 117# I tried to accommodate this with regular expressions such as 118# "((class|struct) A \{ public:|struct A \{)", but that turns into a 119# hairy mess because of optional private virtual base pointers and 120# optional public synthetic operators. This is the big reason I gave 121# up on regular expressions and started parsing the output. 122# 123# . REDUNDANT ACCESS SPECIFIER 124# 125# In "class { private: ... }" or "struct { public: ... }", gdb might 126# or might not emit a redundant initial access specifier, depending 127# on the gcc version. 128# 129# . VIRTUAL BASE POINTERS 130# 131# If a class has virtual bases, either direct or indirect, the class 132# will have virtual base pointers. With gcc 2.95.3, gdb prints lines 133# for these virtual base pointers. This does not happen with gcc 134# 3.3.4, gcc 3.4.1, or hp acc A.03.45. 135# 136# I accept these lines. These lines are optional; but if I see one of 137# these lines, then I expect to see all of them. 138# 139# Note: drow considers printing these lines to be a bug in gdb. 140# 141# . SYNTHETIC METHODS 142# 143# A C++ compiler may synthesize some methods: an assignment 144# operator, a copy constructor, a constructor, and a destructor. The 145# compiler might include debug information for these methods. 146# 147# dwarf-2 gdb does not show these methods 148# stabs+ gdb shows these methods 149# hp gdb does not show these methods 150# 151# I accept these methods. These lines are optional, and any or 152# all of them might appear, mixed in anywhere in the regular methods. 153# 154# With gcc v2, the synthetic copy-ctor and ctor have an additional 155# "int" parameter at the beginning, the "in-charge" flag. 156# 157# . DEMANGLER SYNTAX VARIATIONS 158# 159# Different demanglers produce "int foo(void)" versus "int foo()", 160# "const A&" versus "const A &", and so on. 161# 162# TESTED WITH 163# 164# gcc 2.95.3 -gdwarf-2 165# gcc 2.95.3 -gstabs+ 166# gcc 3.3.4 -gdwarf-2 167# gcc 3.3.4 -gstabs+ 168# gcc 3.4.1 -gdwarf-2 169# gcc 3.4.1 -gstabs+ 170# gcc HEAD 20040731 -gdwarf-2 171# gcc HEAD 20040731 -gstabs+ 172# 173# TODO 174# 175# Tagless structs. 176# 177# "A*" versus "A *" and "A&" versus "A &" in user methods. 178# 179# Test with hp ACC. 180# 181# -- chastain 2004-08-07 182 183proc cp_test_ptype_class { in_exp in_testname in_key in_tag in_class_table { in_tail "" } { in_errata_table { } } { in_ptype_arg /r } } { 184 global gdb_prompt 185 set wsopt "\[\r\n\t \]*" 186 187 # The test name defaults to the command, but without the 188 # arguments, for historical reasons. 189 190 if { "$in_testname" == "" } then { set in_testname "ptype $in_exp" } 191 192 set in_command "ptype${in_ptype_arg} $in_exp" 193 194 # Save class tables in a history array for reuse. 195 196 global cp_class_table_history 197 if { $in_class_table == "ibid" } then { 198 if { ! [info exists cp_class_table_history("$in_key,$in_tag") ] } then { 199 fail "$in_testname // bad ibid" 200 return 201 } 202 set in_class_table $cp_class_table_history("$in_key,$in_tag") 203 } else { 204 set cp_class_table_history("$in_key,$in_tag") $in_class_table 205 } 206 207 # Split the class table into separate tables. 208 209 set list_bases { } 210 set list_vbases { } 211 set list_fields { } 212 set list_methods { } 213 set list_typedefs { } 214 215 foreach class_line $in_class_table { 216 switch [lindex $class_line 0] { 217 "base" { lappend list_bases [lindex $class_line 1] } 218 "vbase" { lappend list_vbases [lindex $class_line 1] } 219 "field" { lappend list_fields [lrange $class_line 1 2] } 220 "method" { lappend list_methods [lrange $class_line 1 2] } 221 "typedef" { lappend list_typedefs [lrange $class_line 1 2] } 222 default { fail "$in_testname // bad line in class table: $class_line"; return; } 223 } 224 } 225 226 # Construct a list of synthetic operators. 227 # These are: { count ccess-type regular-expression }. 228 229 set list_synth { } 230 lappend list_synth [list 0 "public" "$in_tag & operator=\\($in_tag const ?&\\);"] 231 lappend list_synth [list 0 "public" "$in_tag\\((int,|) ?$in_tag const ?&\\);"] 232 lappend list_synth [list 0 "public" "$in_tag\\((int|void|)\\);"] 233 234 # Actually do the ptype. 235 236 set parse_okay 0 237 gdb_test_multiple "$in_command" "$in_testname // parse failed" { 238 -re "type = (struct|class)${wsopt}(\[^ \t\]*)${wsopt}(\\\[with .*\\\]${wsopt})?((:\[^\{\]*)?)${wsopt}\{(.*)\}${wsopt}(\[^\r\n\]*)\[\r\n\]+$gdb_prompt $" { 239 set parse_okay 1 240 set actual_key $expect_out(1,string) 241 set actual_tag $expect_out(2,string) 242 set actual_base_string $expect_out(4,string) 243 set actual_body $expect_out(6,string) 244 set actual_tail $expect_out(7,string) 245 } 246 } 247 if { ! $parse_okay } then { return } 248 249 # Check the actual key. It would be nice to require that it match 250 # the input key, but gdb does not support that. For now, accept any 251 # $actual_key as long as the access property of each field/method 252 # matches. 253 254 switch "$actual_key" { 255 "class" { set access "private" } 256 "struct" { set access "public" } 257 default { 258 cp_check_errata "class" "$actual_key" $in_errata_table 259 cp_check_errata "struct" "$actual_key" $in_errata_table 260 fail "$in_testname // wrong key: $actual_key" 261 return 262 } 263 } 264 265 # Check the actual tag. 266 267 if { "$actual_tag" != "$in_tag" } then { 268 cp_check_errata "$in_tag" "$actual_tag" $in_errata_table 269 fail "$in_testname // wrong tag: $actual_tag" 270 return 271 } 272 273 # Check the actual bases. 274 # First parse them into a list. 275 276 set list_actual_bases { } 277 if { "$actual_base_string" != "" } then { 278 regsub "^:${wsopt}" $actual_base_string "" actual_base_string 279 set list_actual_bases [split $actual_base_string ","] 280 } 281 282 # Check the base count. 283 284 if { [llength $list_actual_bases] < [llength $list_bases] } then { 285 fail "$in_testname // too few bases" 286 return 287 } 288 if { [llength $list_actual_bases] > [llength $list_bases] } then { 289 fail "$in_testname // too many bases" 290 return 291 } 292 293 # Check each base. 294 295 foreach actual_base $list_actual_bases { 296 set actual_base [string trim $actual_base] 297 set base [lindex $list_bases 0] 298 if { "$actual_base" != "$base" } then { 299 cp_check_errata "$base" "$actual_base" $in_errata_table 300 fail "$in_testname // wrong base: $actual_base" 301 return 302 } 303 set list_bases [lreplace $list_bases 0 0] 304 } 305 306 # Parse each line in the body. 307 308 set last_was_access 0 309 set vbase_match 0 310 311 foreach actual_line [split $actual_body "\r\n"] { 312 313 # Chomp the line. 314 315 set actual_line [string trim $actual_line] 316 if { "$actual_line" == "" } then { continue } 317 318 # Access specifiers. 319 320 if { [regexp "^(public|protected|private)${wsopt}:\$" "$actual_line" s0 s1] } then { 321 set access "$s1" 322 if { $last_was_access } then { 323 fail "$in_testname // redundant access specifier" 324 return 325 } 326 set last_was_access 1 327 continue 328 } else { 329 set last_was_access 0 330 } 331 332 # Optional virtual base pointer. 333 334 if { [ llength $list_vbases ] > 0 } then { 335 set vbase [lindex $list_vbases 0] 336 if { [ regexp "$vbase \\*(_vb.|_vb\\\$|__vb_)\[0-9\]*$vbase;" $actual_line ] } then { 337 if { "$access" != "private" } then { 338 cp_check_errata "private" "$access" $in_errata_table 339 fail "$in_testname // wrong access specifier for virtual base: $access" 340 return 341 } 342 set list_vbases [lreplace $list_vbases 0 0] 343 set vbase_match 1 344 continue 345 } 346 } 347 348 # Data field. 349 350 if { [llength $list_fields] > 0 } then { 351 set field_access [lindex [lindex $list_fields 0] 0] 352 set field_decl [lindex [lindex $list_fields 0] 1] 353 if { "$actual_line" == "$field_decl" } then { 354 if { "$access" != "$field_access" } then { 355 cp_check_errata "$field_access" "$access" $in_errata_table 356 fail "$in_testname // wrong access specifier for field: $access" 357 return 358 } 359 set list_fields [lreplace $list_fields 0 0] 360 continue 361 } 362 363 # Data fields must appear before synths and methods. 364 cp_check_errata "$field_decl" "$actual_line" $in_errata_table 365 fail "$in_testname // unrecognized line type 1: $actual_line" 366 return 367 } 368 369 # Method function. 370 371 if { [llength $list_methods] > 0 } then { 372 set method_access [lindex [lindex $list_methods 0] 0] 373 set method_decl [lindex [lindex $list_methods 0] 1] 374 if { "$actual_line" == "$method_decl" } then { 375 if { "$access" != "$method_access" } then { 376 cp_check_errata "$method_access" "$access" $in_errata_table 377 fail "$in_testname // wrong access specifier for method: $access" 378 return 379 } 380 set list_methods [lreplace $list_methods 0 0] 381 continue 382 } 383 384 # gcc 2.95.3 shows "foo()" as "foo(void)". 385 regsub -all "\\(\\)" $method_decl "(void)" method_decl 386 if { "$actual_line" == "$method_decl" } then { 387 if { "$access" != "$method_access" } then { 388 cp_check_errata "$method_access" "$access" $in_errata_table 389 fail "$in_testname // wrong access specifier for method: $access" 390 return 391 } 392 set list_methods [lreplace $list_methods 0 0] 393 continue 394 } 395 } 396 397 # Typedef 398 399 if {[llength $list_typedefs] > 0} { 400 set typedef_access [lindex [lindex $list_typedefs 0] 0] 401 set typedef_decl [lindex [lindex $list_typedefs 0] 1] 402 if {[string equal $actual_line $typedef_decl]} { 403 if {![string equal $access $typedef_access]} { 404 cp_check_errata $typedef_access $access $in_errata_table 405 fail "$in_testname // wrong access specifier for typedef: $access" 406 return 407 } 408 set list_typedefs [lreplace $list_typedefs 0 0] 409 continue 410 } 411 } 412 413 # Synthetic operators. These are optional and can be mixed in 414 # with the methods in any order, but duplicates are wrong. 415 # 416 # This test must come after the user methods, so that a user 417 # method which matches a synth-method pattern is treated 418 # properly as a user method. 419 420 set synth_match 0 421 for { set isynth 0 } { $isynth < [llength $list_synth] } { incr isynth } { 422 set synth [lindex $list_synth $isynth] 423 set synth_count [lindex $synth 0] 424 set synth_access [lindex $synth 1] 425 set synth_re [lindex $synth 2] 426 427 if { [ regexp "$synth_re" "$actual_line" ] } then { 428 429 if { "$access" != "$synth_access" } then { 430 cp_check_errata "$synth_access" "$access" $in_errata_table 431 fail "$in_testname // wrong access specifier for synthetic operator: $access" 432 return 433 } 434 435 if { $synth_count > 0 } then { 436 cp_check_errata "$actual_line" "$actual_line" $in_errata_table 437 fail "$in_testname // duplicate synthetic operator: $actual_line" 438 } 439 440 # Update the count in list_synth. 441 442 incr synth_count 443 set synth [list $synth_count $synth_access "$synth_re"] 444 set list_synth [lreplace $list_synth $isynth $isynth $synth] 445 446 # Match found. 447 448 set synth_match 1 449 break 450 } 451 } 452 if { $synth_match } then { continue } 453 454 # Unrecognized line. 455 456 if { [llength $list_methods] > 0 } then { 457 set method_decl [lindex [lindex $list_methods 0] 1] 458 cp_check_errata "$method_decl" "$actual_line" $in_errata_table 459 } 460 461 fail "$in_testname // unrecognized line type 2: $actual_line" 462 return 463 } 464 465 # Check for missing elements. 466 467 if { $vbase_match } then { 468 if { [llength $list_vbases] > 0 } then { 469 fail "$in_testname // missing virtual base pointers" 470 return 471 } 472 } 473 474 if { [llength $list_fields] > 0 } then { 475 fail "$in_testname // missing fields" 476 return 477 } 478 479 if { [llength $list_methods] > 0 } then { 480 fail "$in_testname // missing methods" 481 return 482 } 483 484 if {[llength $list_typedefs] > 0} { 485 fail "$in_testname // missing typedefs" 486 return 487 } 488 489 # Check the tail. 490 491 set actual_tail [string trim $actual_tail] 492 if { "$actual_tail" != "$in_tail" } then { 493 cp_check_errata "$in_tail" "$actual_tail" $in_errata_table 494 fail "$in_testname // wrong tail: $actual_tail" 495 return 496 } 497 498 # It all worked! 499 500 pass "$in_testname" 501 return 502} 503