1#!/bin/sh 2 3# GDB script to list of problems using awk. 4# 5# Copyright (C) 2002-2023 Free Software Foundation, Inc. 6# 7# This file is part of GDB. 8# 9# This program is free software; you can redistribute it and/or modify 10# it under the terms of the GNU General Public License as published by 11# the Free Software Foundation; either version 3 of the License, or 12# (at your option) any later version. 13# 14# This program is distributed in the hope that it will be useful, 15# but WITHOUT ANY WARRANTY; without even the implied warranty of 16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17# GNU General Public License for more details. 18# 19# You should have received a copy of the GNU General Public License 20# along with this program. If not, see <http://www.gnu.org/licenses/>. 21 22# Make certain that the script is not running in an internationalized 23# environment. 24 25LANG=C ; export LANG 26LC_ALL=C ; export LC_ALL 27 28# Permanent checks take the form: 29 30# Do not use XXXX, C++11 implies YYYY 31# Do not use XXXX, instead use YYYY''. 32 33# and should never be removed. 34 35# Temporary checks take the form: 36 37# Replace XXXX with YYYY 38 39# and once they reach zero, can be eliminated. 40 41# FIXME: It should be able to override this on the command line 42error="regression" 43warning="regression" 44ari="regression eol code comment deprecated legacy obsolete gettext" 45all="regression eol code comment deprecated legacy obsolete gettext deprecate internal gdbarch macro" 46print_doc=0 47print_idx=0 48 49usage () 50{ 51 cat <<EOF 1>&2 52Error: $1 53 54Usage: 55 $0 --print-doc --print-idx -Wall -Werror -WCATEGORY FILE ... 56Options: 57 --print-doc Print a list of all potential problems, then exit. 58 --print-idx Include the problems IDX (index or key) in every message. 59 --src=file Write source lines to file. 60 -Werror Treat all problems as errors. 61 -Wall Report all problems. 62 -Wari Report problems that should be fixed in new code. 63 -WCATEGORY Report problems in the specifed category. The category 64 can be prefixed with "no-". Valid categories 65 are: ${all} 66EOF 67 exit 1 68} 69 70 71# Parse the various options 72Woptions= 73srclines="" 74while test $# -gt 0 75do 76 case "$1" in 77 -Wall ) Woptions="${all}" ;; 78 -Wari ) Woptions="${ari}" ;; 79 -Werror ) Werror=1 ;; 80 -W* ) Woptions="${Woptions} `echo x$1 | sed -e 's/x-W//'`" ;; 81 --print-doc ) print_doc=1 ;; 82 --print-idx ) print_idx=1 ;; 83 --src=* ) srclines="`echo $1 | sed -e 's/--src=/srclines=\"/'`\"" ;; 84 -- ) shift ; break ;; 85 - ) break ;; 86 -* ) usage "$1: unknown option" ;; 87 * ) break ;; 88 esac 89 shift 90done 91if test -n "$Woptions" ; then 92 warning="$Woptions" 93 error= 94fi 95 96 97# -Werror implies treating all warnings as errors. 98if test -n "${Werror}" ; then 99 error="${error} ${warning}" 100fi 101 102 103# Validate all errors and warnings. 104for w in ${warning} ${error} 105do 106 case "$w" in 107 no-*) w=`echo x$w | sed -e 's/xno-//'`;; 108 esac 109 110 case " ${all} " in 111 *" ${w} "* ) ;; 112 * ) usage "Unknown option -W${w}" ;; 113 esac 114done 115 116 117# make certain that there is at least one file. 118if test $# -eq 0 -a ${print_doc} = 0 119then 120 usage "Missing file." 121fi 122 123 124# Convert the errors/warnings into corresponding array entries. 125for a in ${all} 126do 127 aris="${aris} ari_${a} = \"${a}\";" 128done 129for w in ${warning} 130do 131 val=1 132 case "$w" in 133 no-*) w=`echo x$w | sed -e 's/xno-//'`; val=0 ;; 134 esac 135 warnings="${warnings} warning[ari_${w}] = $val;" 136done 137for e in ${error} 138do 139 val=1 140 case "$e" in 141 no-*) e=`echo x$e | sed -e 's/xno-//'`; val=0 ;; 142 esac 143 errors="${errors} error[ari_${e}] = $val;" 144done 145 146if [ "$AWK" = "" ] ; then 147 AWK=awk 148fi 149 150${AWK} -- ' 151BEGIN { 152 # NOTE, for a per-file begin use "FNR == 1". 153 '"${aris}"' 154 '"${errors}"' 155 '"${warnings}"' 156 '"${srclines}"' 157 print_doc = '$print_doc' 158 print_idx = '$print_idx' 159 PWD = "'`pwd`'" 160} 161 162# Print the error message for BUG. Append SUPLEMENT if non-empty. 163function print_bug(file,line,prefix,category,bug,doc,supplement, suffix,idx) { 164 if (print_idx) { 165 idx = bug ": " 166 } else { 167 idx = "" 168 } 169 if (supplement) { 170 suffix = " (" supplement ")" 171 } else { 172 suffix = "" 173 } 174 # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC> 175 print file ":" line ": " prefix category ": " idx doc suffix 176 if (srclines != "") { 177 print file ":" line ":" $0 >> srclines 178 } 179} 180 181function fix(bug,file,count) { 182 skip[bug, file] = count 183 skipped[bug, file] = 0 184} 185 186function fail(bug,supplement) { 187 if (doc[bug] == "") { 188 print_bug("", 0, "internal: ", "internal", "internal", "Missing doc for bug " bug) 189 exit 190 } 191 if (category[bug] == "") { 192 print_bug("", 0, "internal: ", "internal", "internal", "Missing category for bug " bug) 193 exit 194 } 195 196 if (ARI_OK == bug) { 197 return 198 } 199 # Trim the filename down to just DIRECTORY/FILE so that it can be 200 # robustly used by the FIX code. 201 202 if (FILENAME ~ /^\//) { 203 canonicalname = FILENAME 204 } else { 205 canonicalname = PWD "/" FILENAME 206 } 207 shortname = gensub (/^.*\/([^\\]*\/[^\\]*)$/, "\\1", 1, canonicalname) 208 209 skipped[bug, shortname]++ 210 if (skip[bug, shortname] >= skipped[bug, shortname]) { 211 # print FILENAME, FNR, skip[bug, FILENAME], skipped[bug, FILENAME], bug 212 # Do nothing 213 } else if (error[category[bug]]) { 214 # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC> 215 print_bug(FILENAME, FNR, "", category[bug], bug, doc[bug], supplement) 216 } else if (warning[category[bug]]) { 217 # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC> 218 print_bug(FILENAME, FNR, "warning: ", category[bug], bug, doc[bug], supplement) 219 } 220} 221 222FNR == 1 { 223 seen[FILENAME] = 1 224 if (match(FILENAME, "\\.[ly]$")) { 225 # FILENAME is a lex or yacc source 226 is_yacc_or_lex = 1 227 } 228 else { 229 is_yacc_or_lex = 0 230 } 231} 232END { 233 if (print_idx) { 234 idx = bug ": " 235 } else { 236 idx = "" 237 } 238 # Did we do only a partial skip? 239 for (bug_n_file in skip) { 240 split (bug_n_file, a, SUBSEP) 241 bug = a[1] 242 file = a[2] 243 if (seen[file] && (skipped[bug_n_file] < skip[bug_n_file])) { 244 # ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC> 245 b = file " missing " bug 246 print_bug(file, 0, "", "internal", file " missing " bug, "Expecting " skip[bug_n_file] " occurances of bug " bug " in file " file ", only found " skipped[bug_n_file]) 247 } 248 } 249} 250 251 252# Skip OBSOLETE lines 253/(^|[^_[:alnum:]])OBSOLETE([^_[:alnum:]]|$)/ { next; } 254 255# Skip ARI lines 256 257BEGIN { 258 ARI_OK = "" 259} 260 261/\/\* ARI:[[:space:]]*(.*)[[:space:]]*\*\// { 262 ARI_OK = gensub(/^.*\/\* ARI:[[:space:]]*(.*[^[:space:]])[[:space:]]*\*\/.*$/, "\\1", 1, $0) 263 # print "ARI line found \"" $0 "\"" 264 # print "ARI_OK \"" ARI_OK "\"" 265} 266! /\/\* ARI:[[:space:]]*(.*)[[:space:]]*\*\// { 267 ARI_OK = "" 268} 269 270 271# SNIP - Strip out comments - SNIP 272 273FNR == 1 { 274 comment_p = 0 275} 276comment_p && /\*\// { gsub (/^([^\*]|\*+[^\/\*])*\*+\//, " "); comment_p = 0; } 277comment_p { next; } 278!comment_p { gsub (/\/\*([^\*]|\*+[^\/\*])*\*+\//, " "); } 279!comment_p && /(^|[^"])\/\*/ { gsub (/\/\*.*$/, " "); comment_p = 1; } 280 281 282BEGIN { doc["_ markup"] = "\ 283All messages should be marked up with _." 284 category["_ markup"] = ari_gettext 285} 286/^[^"]*[[:space:]](warning|error|error_no_arg|query|perror_with_name)[[:space:]]*\([^_\(a-z]/ { 287 if (! /\("%s"/) { 288 fail("_ markup") 289 } 290} 291 292BEGIN { doc["trailing new line"] = "\ 293A message should not have a trailing new line" 294 category["trailing new line"] = ari_gettext 295} 296/(^|[^_[:alnum:]])(warning|error)[[:space:]]*\(_\(".*\\n"\)[\),]/ { 297 fail("trailing new line") 298} 299 300# Include files for which GDB has a custom version. 301 302BEGIN { doc["assert.h"] = "\ 303Do not include assert.h, instead include \"gdb_assert.h\""; 304 category["assert.h"] = ari_regression 305 fix("assert.h", "gdb/gdb_assert.h", 0) # it does not use it 306} 307/^#[[:space:]]*include[[:space:]]+.assert\.h./ { 308 fail("assert.h") 309} 310 311BEGIN { doc["regex.h"] = "\ 312Do not include regex.h, instead include gdb_regex.h" 313 category["regex.h"] = ari_regression 314 fix("regex.h", "gdb/gdb_regex.h", 1) 315} 316/^#[[:space:]]*include[[:space:]]*.regex\.h./ { 317 fail("regex.h") 318} 319 320BEGIN { doc["xregex.h"] = "\ 321Do not include xregex.h, instead include gdb_regex.h" 322 category["xregex.h"] = ari_regression 323 fix("xregex.h", "gdb/gdb_regex.h", 1) 324} 325/^#[[:space:]]*include[[:space:]]*.xregex\.h./ { 326 fail("xregex.h") 327} 328 329BEGIN { doc["gnu-regex.h"] = "\ 330Do not include gnu-regex.h, instead include gdb_regex.h" 331 category["gnu-regex.h"] = ari_regression 332} 333/^#[[:space:]]*include[[:space:]]*.gnu-regex\.h./ { 334 fail("gnu regex.h") 335} 336 337BEGIN { doc["wait.h"] = "\ 338Do not include wait.h or sys/wait.h, instead include gdb_wait.h" 339 fix("wait.h", "gdbsupport/gdb_wait.h", 2); 340 category["wait.h"] = ari_regression 341} 342/^#[[:space:]]*include[[:space:]]*.wait\.h./ \ 343|| /^#[[:space:]]*include[[:space:]]*.sys\/wait\.h./ { 344 fail("wait.h") 345} 346 347BEGIN { doc["vfork.h"] = "\ 348Do not include vfork.h, instead include gdb_vfork.h" 349 fix("vfork.h", "gdb/gdb_vfork.h", 1); 350 category["vfork.h"] = ari_regression 351} 352/^#[[:space:]]*include[[:space:]]*.vfork\.h./ { 353 fail("vfork.h") 354} 355 356BEGIN { doc["error not internal-warning"] = "\ 357Do not use error(\"internal-warning\"), instead use internal_warning" 358 category["error not internal-warning"] = ari_regression 359} 360/error.*\"[Ii]nternal.warning/ { 361 fail("error not internal-warning") 362} 363 364BEGIN { doc["%p"] = "\ 365Do not use printf(\"%p\"), instead use printf(\"%s\",paddr()) to dump a \ 366target address, or host_address_to_string() for a host address" 367 category["%p"] = ari_code 368} 369# Allow gdb %p extensions, but not other uses of %p. 370/%p[^[\]sF]/ && !/%prec/ { 371 fail("%p") 372} 373 374BEGIN { doc["%ll"] = "\ 375Do not use printf(\"%ll\"), instead use printf(\"%s\",phex()) to dump a \ 376`long long'\'' value" 377 category["%ll"] = ari_code 378} 379# Allow %ll in scanf 380/%[0-9]*ll/ && !/scanf \(.*%[0-9]*ll/ { 381 fail("%ll") 382} 383 384 385# SNIP - Strip out strings - SNIP 386 387# Test on top.c, scm-valprint.c, remote-rdi.c, ada-lang.c 388FNR == 1 { 389 string_p = 0 390 trace_string = 0 391} 392# Strip escaped characters. 393{ gsub(/\\./, "."); } 394# Strip quoted quotes. 395{ gsub(/'\''.'\''/, "'\''.'\''"); } 396# End of multi-line string 397string_p && /\"/ { 398 if (trace_string) print "EOS:" FNR, $0; 399 gsub (/^[^\"]*\"/, "'\''"); 400 string_p = 0; 401} 402# Middle of multi-line string, discard line. 403string_p { 404 if (trace_string) print "MOS:" FNR, $0; 405 $0 = "" 406} 407# Strip complete strings from the middle of the line 408!string_p && /\"[^\"]*\"/ { 409 if (trace_string) print "COS:" FNR, $0; 410 gsub (/\"[^\"]*\"/, "'\''"); 411} 412# Start of multi-line string 413BEGIN { doc["multi-line string"] = "\ 414Multi-line string must have the newline escaped" 415 category["multi-line string"] = ari_regression 416} 417!string_p && /\"/ { 418 if (trace_string) print "SOS:" FNR, $0; 419 if (/[^\\]$/) { 420 fail("multi-line string") 421 } 422 gsub (/\"[^\"]*$/, "'\''"); 423 string_p = 1; 424} 425# { print } 426 427# Multi-line string 428string_p && 429 430# Accumulate continuation lines 431FNR == 1 { 432 cont_p = 0 433} 434!cont_p { full_line = ""; } 435/[^\\]\\$/ { gsub (/\\$/, ""); full_line = full_line $0; cont_p = 1; next; } 436cont_p { $0 = full_line $0; cont_p = 0; full_line = ""; } 437 438 439BEGIN { doc["__FUNCTION__"] = "\ 440Do not use __FUNCTION__, C++11 does not support this macro" 441 category["__FUNCTION__"] = ari_regression 442} 443/(^|[^_[:alnum:]])__FUNCTION__([^_[:alnum:]]|$)/ { 444 fail("__FUNCTION__") 445} 446 447BEGIN { doc["__CYGWIN32__"] = "\ 448Do not use __CYGWIN32__, instead use __CYGWIN__ or, better, an explicit \ 449autoconf tests" 450 category["__CYGWIN32__"] = ari_regression 451} 452/(^|[^_[:alnum:]])__CYGWIN32__([^_[:alnum:]]|$)/ { 453 fail("__CYGWIN32__") 454} 455 456BEGIN { doc["PTR"] = "\ 457Do not use PTR, C++11 implies `void *'\''" 458 category["PTR"] = ari_regression 459 #fix("PTR", "gdb/utils.c", 6) 460} 461/(^|[^_[:alnum:]])PTR([^_[:alnum:]]|$)/ { 462 fail("PTR") 463} 464 465BEGIN { doc["UCASE function"] = "\ 466Function name is uppercase." 467 category["UCASE function"] = ari_code 468 possible_UCASE = 0 469 UCASE_full_line = "" 470} 471(possible_UCASE) { 472 if (ARI_OK == "UCASE function") { 473 possible_UCASE = 0 474 } 475 # Closing brace found? 476 else if (UCASE_full_line ~ \ 477 /^[A-Z][[:alnum:]_]*[[:space:]]*\([^()]*\).*$/) { 478 if ((UCASE_full_line ~ \ 479 /^[A-Z][[:alnum:]_]*[[:space:]]*\([^()]*\)[[:space:]]*$/) \ 480 && ($0 ~ /^\{/) && (is_yacc_or_lex == 0)) { 481 store_FNR = FNR 482 FNR = possible_FNR 483 store_0 = $0; 484 $0 = UCASE_full_line; 485 fail("UCASE function") 486 FNR = store_FNR 487 $0 = store_0; 488 } 489 possible_UCASE = 0 490 UCASE_full_line = "" 491 } else { 492 UCASE_full_line = UCASE_full_line $0; 493 } 494} 495/^[A-Z][[:alnum:]_]*[[:space:]]*\([^()]*(|\))[[:space:]]*$/ { 496 possible_UCASE = 1 497 if (ARI_OK == "UCASE function") { 498 possible_UCASE = 0 499 } 500 possible_FNR = FNR 501 UCASE_full_line = $0 502} 503 504 505BEGIN { doc["editCase function"] = "\ 506Function name starts lower case but has uppercased letters." 507 category["editCase function"] = ari_code 508 possible_editCase = 0 509 editCase_full_line = "" 510} 511(possible_editCase) { 512 if (ARI_OK == "editCase function") { 513 possible_editCase = 0 514 } 515 # Closing brace found? 516 else if (editCase_full_line ~ \ 517/^[a-z][a-z0-9_]*[A-Z][a-z0-9A-Z_]*[[:space:]]*\([^()]*\).*$/) { 518 if ((editCase_full_line ~ \ 519/^[a-z][a-z0-9_]*[A-Z][a-z0-9A-Z_]*[[:space:]]*\([^()]*\)[[:space:]]*$/) \ 520 && ($0 ~ /^\{/) && (is_yacc_or_lex == 0)) { 521 store_FNR = FNR 522 FNR = possible_FNR 523 store_0 = $0; 524 $0 = editCase_full_line; 525 fail("editCase function") 526 FNR = store_FNR 527 $0 = store_0; 528 } 529 possible_editCase = 0 530 editCase_full_line = "" 531 } else { 532 editCase_full_line = editCase_full_line $0; 533 } 534} 535/^[a-z][a-z0-9_]*[A-Z][a-z0-9A-Z_]*[[:space:]]*\([^()]*(|\))[[:space:]]*$/ { 536 possible_editCase = 1 537 if (ARI_OK == "editCase function") { 538 possible_editCase = 0 539 } 540 possible_FNR = FNR 541 editCase_full_line = $0 542} 543 544# Only function implementation should be on first column 545BEGIN { doc["function call in first column"] = "\ 546Function name in first column should be restricted to function implementation" 547 category["function call in first column"] = ari_code 548} 549/^[a-z][a-z0-9_]*[[:space:]]*\((|[^*][^()]*)\)[[:space:]]*[^ \t]+/ { 550 fail("function call in first column") 551} 552 553 554BEGIN { doc["hash"] = "\ 555Do not use ` #...'\'', instead use `#...'\''(some compilers only correctly \ 556parse a C preprocessor directive when `#'\'' is the first character on \ 557the line)" 558 category["hash"] = ari_regression 559} 560/^[[:space:]]+#/ { 561 fail("hash") 562} 563 564BEGIN { doc["OP eol"] = "\ 565Do not use &&, or || at the end of a line" 566 category["OP eol"] = ari_code 567} 568# * operator needs a special treatment as it can be a 569# valid end of line for a pointer type definition 570# Only catch case where an assignment or an opening brace is present 571/(\|\||\&\&|==|!=|[[:space:]][+\-\/])[[:space:]]*$/ \ 572|| /(\(|=)[[:space:]].*[[:space:]]\*[[:space:]]*$/ { 573 fail("OP eol") 574} 575 576BEGIN { doc["strerror"] = "\ 577Do not use strerror(), instead use safe_strerror()" 578 category["strerror"] = ari_regression 579 fix("strerror", "gdb/gdb_string.h", 1) 580 fix("strerror", "gdb/gdbsupport/mingw-strerror.c", 1) 581 fix("strerror", "gdb/gdbsupport/posix-strerror.c", 1) 582} 583/(^|[^_[:alnum:]])strerror[[:space:]]*\(/ { 584 fail("strerror") 585} 586 587BEGIN { doc["long long"] = "\ 588Do not use `long long'\'', instead use LONGEST" 589 category["long long"] = ari_code 590} 591/(^|[^_[:alnum:]])long[[:space:]]+long([^_[:alnum:]]|$)/ { 592 fail("long long") 593} 594 595BEGIN { doc["ATTR_FORMAT"] = "\ 596Do not use ATTR_FORMAT, use ATTRIBUTE_PRINTF instead" 597 category["ATTR_FORMAT"] = ari_regression 598} 599/(^|[^_[:alnum:]])ATTR_FORMAT([^_[:alnum:]]|$)/ { 600 fail("ATTR_FORMAT") 601} 602 603BEGIN { doc["ATTR_NORETURN"] = "\ 604Do not use ATTR_NORETURN, use ATTRIBUTE_NORETURN instead" 605 category["ATTR_NORETURN"] = ari_regression 606} 607/(^|[^_[:alnum:]])ATTR_NORETURN([^_[:alnum:]]|$)/ { 608 fail("ATTR_NORETURN") 609} 610 611BEGIN { doc["NORETURN"] = "\ 612Do not use NORETURN, use ATTRIBUTE_NORETURN instead" 613 category["NORETURN"] = ari_regression 614} 615/(^|[^_[:alnum:]])NORETURN([^_[:alnum:]]|$)/ { 616 fail("NORETURN") 617} 618 619 620# General problems 621 622# Commented out, but left inside sources, just in case. 623# BEGIN { doc["inline"] = "\ 624# Do not use the inline attribute; \ 625# since the compiler generally ignores this, better algorithm selection \ 626# is needed to improved performance" 627# category["inline"] = ari_code 628# } 629# /(^|[^_[:alnum:]])inline([^_[:alnum:]]|$)/ { 630# fail("inline") 631# } 632 633# This test is obsolete as this type 634# has been deprecated and finally suppressed from GDB sources 635#BEGIN { doc["obj_private"] = "\ 636#Replace obj_private with objfile_data" 637# category["obj_private"] = ari_obsolete 638#} 639#/(^|[^_[:alnum:]])obj_private([^_[:alnum:]]|$)/ { 640# fail("obj_private") 641#} 642 643BEGIN { doc["abort"] = "\ 644Do not use abort, instead use internal_error; GDB should never abort" 645 category["abort"] = ari_regression 646} 647/(^|[^_[:alnum:]])abort[[:space:]]*\(/ { 648 fail("abort") 649} 650 651BEGIN { doc["basename"] = "\ 652Do not use basename, instead use lbasename" 653 category["basename"] = ari_regression 654} 655/(^|[^_[:alnum:]])basename[[:space:]]*\(/ { 656 fail("basename") 657} 658 659BEGIN { doc["assert"] = "\ 660Do not use assert, instead use gdb_assert or internal_error; assert \ 661calls abort and GDB should never call abort" 662 category["assert"] = ari_regression 663} 664/(^|[^_[:alnum:]])assert[[:space:]]*\(/ { 665 fail("assert") 666} 667 668BEGIN { doc["TARGET_HAS_HARDWARE_WATCHPOINTS"] = "\ 669Replace TARGET_HAS_HARDWARE_WATCHPOINTS with nothing, not needed" 670 category["TARGET_HAS_HARDWARE_WATCHPOINTS"] = ari_regression 671} 672/(^|[^_[:alnum:]])TARGET_HAS_HARDWARE_WATCHPOINTS([^_[:alnum:]]|$)/ { 673 fail("TARGET_HAS_HARDWARE_WATCHPOINTS") 674} 675 676BEGIN { doc["ADD_SHARED_SYMBOL_FILES"] = "\ 677Replace ADD_SHARED_SYMBOL_FILES with nothing, not needed?" 678 category["ADD_SHARED_SYMBOL_FILES"] = ari_regression 679} 680/(^|[^_[:alnum:]])ADD_SHARED_SYMBOL_FILES([^_[:alnum:]]|$)/ { 681 fail("ADD_SHARED_SYMBOL_FILES") 682} 683 684BEGIN { doc["SOLIB_ADD"] = "\ 685Replace SOLIB_ADD with nothing, not needed?" 686 category["SOLIB_ADD"] = ari_regression 687} 688/(^|[^_[:alnum:]])SOLIB_ADD([^_[:alnum:]]|$)/ { 689 fail("SOLIB_ADD") 690} 691 692BEGIN { doc["SOLIB_CREATE_INFERIOR_HOOK"] = "\ 693Replace SOLIB_CREATE_INFERIOR_HOOK with nothing, not needed?" 694 category["SOLIB_CREATE_INFERIOR_HOOK"] = ari_regression 695} 696/(^|[^_[:alnum:]])SOLIB_CREATE_INFERIOR_HOOK([^_[:alnum:]]|$)/ { 697 fail("SOLIB_CREATE_INFERIOR_HOOK") 698} 699 700BEGIN { doc["SOLIB_LOADED_LIBRARY_PATHNAME"] = "\ 701Replace SOLIB_LOADED_LIBRARY_PATHNAME with nothing, not needed?" 702 category["SOLIB_LOADED_LIBRARY_PATHNAME"] = ari_regression 703} 704/(^|[^_[:alnum:]])SOLIB_LOADED_LIBRARY_PATHNAME([^_[:alnum:]]|$)/ { 705 fail("SOLIB_LOADED_LIBRARY_PATHNAME") 706} 707 708BEGIN { doc["REGISTER_U_ADDR"] = "\ 709Replace REGISTER_U_ADDR with nothing, not needed?" 710 category["REGISTER_U_ADDR"] = ari_regression 711} 712/(^|[^_[:alnum:]])REGISTER_U_ADDR([^_[:alnum:]]|$)/ { 713 fail("REGISTER_U_ADDR") 714} 715 716BEGIN { doc["PROCESS_LINENUMBER_HOOK"] = "\ 717Replace PROCESS_LINENUMBER_HOOK with nothing, not needed?" 718 category["PROCESS_LINENUMBER_HOOK"] = ari_regression 719} 720/(^|[^_[:alnum:]])PROCESS_LINENUMBER_HOOK([^_[:alnum:]]|$)/ { 721 fail("PROCESS_LINENUMBER_HOOK") 722} 723 724BEGIN { doc["PC_SOLIB"] = "\ 725Replace PC_SOLIB with nothing, not needed?" 726 category["PC_SOLIB"] = ari_regression 727} 728/(^|[^_[:alnum:]])PC_SOLIB([^_[:alnum:]]|$)/ { 729 fail("PC_SOLIB") 730} 731 732BEGIN { doc["IN_SOLIB_DYNSYM_RESOLVE_CODE"] = "\ 733Replace IN_SOLIB_DYNSYM_RESOLVE_CODE with nothing, not needed?" 734 category["IN_SOLIB_DYNSYM_RESOLVE_CODE"] = ari_regression 735} 736/(^|[^_[:alnum:]])IN_SOLIB_DYNSYM_RESOLVE_CODE([^_[:alnum:]]|$)/ { 737 fail("IN_SOLIB_DYNSYM_RESOLVE_CODE") 738} 739 740BEGIN { doc["GCC_COMPILED_FLAG_SYMBOL"] = "\ 741Replace GCC_COMPILED_FLAG_SYMBOL with nothing, not needed?" 742 category["GCC_COMPILED_FLAG_SYMBOL"] = ari_deprecate 743} 744/(^|[^_[:alnum:]])GCC_COMPILED_FLAG_SYMBOL([^_[:alnum:]]|$)/ { 745 fail("GCC_COMPILED_FLAG_SYMBOL") 746} 747 748BEGIN { doc["GCC2_COMPILED_FLAG_SYMBOL"] = "\ 749Replace GCC2_COMPILED_FLAG_SYMBOL with nothing, not needed?" 750 category["GCC2_COMPILED_FLAG_SYMBOL"] = ari_deprecate 751} 752/(^|[^_[:alnum:]])GCC2_COMPILED_FLAG_SYMBOL([^_[:alnum:]]|$)/ { 753 fail("GCC2_COMPILED_FLAG_SYMBOL") 754} 755 756BEGIN { doc["FUNCTION_EPILOGUE_SIZE"] = "\ 757Replace FUNCTION_EPILOGUE_SIZE with nothing, not needed?" 758 category["FUNCTION_EPILOGUE_SIZE"] = ari_regression 759} 760/(^|[^_[:alnum:]])FUNCTION_EPILOGUE_SIZE([^_[:alnum:]]|$)/ { 761 fail("FUNCTION_EPILOGUE_SIZE") 762} 763 764BEGIN { doc["HAVE_VFORK"] = "\ 765Do not use HAVE_VFORK, instead include \"gdb_vfork.h\" and call vfork() \ 766unconditionally" 767 category["HAVE_VFORK"] = ari_regression 768} 769/(^|[^_[:alnum:]])HAVE_VFORK([^_[:alnum:]]|$)/ { 770 fail("HAVE_VFORK") 771} 772 773BEGIN { doc["bcmp"] = "\ 774Do not use bcmp(), C++11 implies memcmp()" 775 category["bcmp"] = ari_regression 776} 777/(^|[^_[:alnum:]])bcmp[[:space:]]*\(/ { 778 fail("bcmp") 779} 780 781BEGIN { doc["setlinebuf"] = "\ 782Do not use setlinebuf(), C++11 implies setvbuf()" 783 category["setlinebuf"] = ari_regression 784} 785/(^|[^_[:alnum:]])setlinebuf[[:space:]]*\(/ { 786 fail("setlinebuf") 787} 788 789BEGIN { doc["bcopy"] = "\ 790Do not use bcopy(), C++11 implies memcpy() and memmove()" 791 category["bcopy"] = ari_regression 792} 793/(^|[^_[:alnum:]])bcopy[[:space:]]*\(/ { 794 fail("bcopy") 795} 796 797BEGIN { doc["get_frame_base"] = "\ 798Replace get_frame_base with get_frame_id, get_frame_base_address, \ 799get_frame_locals_address, or get_frame_args_address." 800 category["get_frame_base"] = ari_obsolete 801} 802/(^|[^_[:alnum:]])get_frame_base([^_[:alnum:]]|$)/ { 803 fail("get_frame_base") 804} 805 806BEGIN { doc["floatformat_to_double"] = "\ 807Do not use floatformat_to_double() from libierty, \ 808instead use floatformat_to_doublest()" 809 category["floatformat_to_double"] = ari_regression 810} 811/(^|[^_[:alnum:]])floatformat_to_double[[:space:]]*\(/ { 812 fail("floatformat_to_double") 813} 814 815BEGIN { doc["floatformat_from_double"] = "\ 816Do not use floatformat_from_double() from libierty, \ 817instead use host_float_ops<T>::from_target()" 818 category["floatformat_from_double"] = ari_regression 819} 820/(^|[^_[:alnum:]])floatformat_from_double[[:space:]]*\(/ { 821 fail("floatformat_from_double") 822} 823 824BEGIN { doc["BIG_ENDIAN"] = "\ 825Do not use BIG_ENDIAN, instead use BFD_ENDIAN_BIG" 826 category["BIG_ENDIAN"] = ari_regression 827} 828/(^|[^_[:alnum:]])BIG_ENDIAN([^_[:alnum:]]|$)/ { 829 fail("BIG_ENDIAN") 830} 831 832BEGIN { doc["LITTLE_ENDIAN"] = "\ 833Do not use LITTLE_ENDIAN, instead use BFD_ENDIAN_LITTLE"; 834 category["LITTLE_ENDIAN"] = ari_regression 835} 836/(^|[^_[:alnum:]])LITTLE_ENDIAN([^_[:alnum:]]|$)/ { 837 fail("LITTLE_ENDIAN") 838} 839 840BEGIN { doc["BIG_ENDIAN"] = "\ 841Do not use BIG_ENDIAN, instead use BFD_ENDIAN_BIG" 842 category["BIG_ENDIAN"] = ari_regression 843} 844/(^|[^_[:alnum:]])BIG_ENDIAN([^_[:alnum:]]|$)/ { 845 fail("BIG_ENDIAN") 846} 847 848BEGIN { doc["sec_ptr"] = "\ 849Instead of sec_ptr, use struct bfd_section"; 850 category["sec_ptr"] = ari_regression 851} 852/(^|[^_[:alnum:]])sec_ptr([^_[:alnum:]]|$)/ { 853 fail("sec_ptr") 854} 855 856BEGIN { doc["frame_unwind_unsigned_register"] = "\ 857Replace frame_unwind_unsigned_register with frame_unwind_register_unsigned" 858 category["frame_unwind_unsigned_register"] = ari_regression 859} 860/(^|[^_[:alnum:]])frame_unwind_unsigned_register([^_[:alnum:]]|$)/ { 861 fail("frame_unwind_unsigned_register") 862} 863 864BEGIN { doc["frame_register_read"] = "\ 865Replace frame_register_read() with get_frame_register(), or \ 866possibly introduce a new method safe_get_frame_register()" 867 category["frame_register_read"] = ari_obsolete 868} 869/(^|[^_[:alnum:]])frame_register_read([^_[:alnum:]]|$)/ { 870 fail("frame_register_read") 871} 872 873BEGIN { doc["read_register"] = "\ 874Replace read_register() with regcache_read() et.al." 875 category["read_register"] = ari_regression 876} 877/(^|[^_[:alnum:]])read_register([^_[:alnum:]]|$)/ { 878 fail("read_register") 879} 880 881BEGIN { doc["write_register"] = "\ 882Replace write_register() with regcache_read() et.al." 883 category["write_register"] = ari_regression 884} 885/(^|[^_[:alnum:]])write_register([^_[:alnum:]]|$)/ { 886 fail("write_register") 887} 888 889function report(name) { 890 # Drop any trailing _P. 891 name = gensub(/(_P|_p)$/, "", 1, name) 892 # Convert to lower case 893 name = tolower(name) 894 # Split into category and bug 895 cat = gensub(/^([[:alpha:]]+)_([_[:alnum:]]*)$/, "\\1", 1, name) 896 bug = gensub(/^([[:alpha:]]+)_([_[:alnum:]]*)$/, "\\2", 1, name) 897 # Report it 898 name = cat " " bug 899 doc[name] = "Do not use " cat " " bug ", see declaration for details" 900 category[name] = cat 901 fail(name) 902} 903 904/(^|[^_[:alnum:]])(DEPRECATED|deprecated|set_gdbarch_deprecated|LEGACY|legacy|set_gdbarch_legacy)_/ { 905 line = $0 906 # print "0 =", $0 907 while (1) { 908 name = gensub(/^(|.*[^_[:alnum:]])((DEPRECATED|deprecated|LEGACY|legacy)_[_[:alnum:]]*)(.*)$/, "\\2", 1, line) 909 line = gensub(/^(|.*[^_[:alnum:]])((DEPRECATED|deprecated|LEGACY|legacy)_[_[:alnum:]]*)(.*)$/, "\\1 \\4", 1, line) 910 # print "name =", name, "line =", line 911 if (name == line) break; 912 report(name) 913 } 914} 915 916# Count the number of times each architecture method is set 917/(^|[^_[:alnum:]])set_gdbarch_[_[:alnum:]]*([^_[:alnum:]]|$)/ { 918 name = gensub(/^.*set_gdbarch_([_[:alnum:]]*).*$/, "\\1", 1, $0) 919 doc["set " name] = "\ 920Call to set_gdbarch_" name 921 category["set " name] = ari_gdbarch 922 fail("set " name) 923} 924 925# Count the number of times each tm/xm/nm macro is defined or undefined 926/^#[[:space:]]*(undef|define)[[:space:]]+[[:alnum:]_]+.*$/ \ 927&& !/^#[[:space:]]*(undef|define)[[:space:]]+[[:alnum:]_]+_H($|[[:space:]])/ \ 928&& FILENAME ~ /(^|\/)config\/(|[^\/]*\/)(tm-|xm-|nm-).*\.h$/ { 929 basename = gensub(/(^|.*\/)([^\/]*)$/, "\\2", 1, FILENAME) 930 type = gensub(/^(tm|xm|nm)-.*\.h$/, "\\1", 1, basename) 931 name = gensub(/^#[[:space:]]*(undef|define)[[:space:]]+([[:alnum:]_]+).*$/, "\\2", 1, $0) 932 if (type == basename) { 933 type = "macro" 934 } 935 doc[type " " name] = "\ 936Do not define macros such as " name " in a tm, nm or xm file, \ 937in fact do not provide a tm, nm or xm file" 938 category[type " " name] = ari_macro 939 fail(type " " name) 940} 941 942BEGIN { doc["deprecated_registers"] = "\ 943Replace deprecated_registers with nothing, they have reached \ 944end-of-life" 945 category["deprecated_registers"] = ari_eol 946} 947/(^|[^_[:alnum:]])deprecated_registers([^_[:alnum:]]|$)/ { 948 fail("deprecated_registers") 949} 950 951BEGIN { doc["read_pc"] = "\ 952Replace READ_PC() with frame_pc_unwind; \ 953at present the inferior function call code still uses this" 954 category["read_pc"] = ari_deprecate 955} 956/(^|[^_[:alnum:]])read_pc[[:space:]]*\(/ || \ 957/(^|[^_[:alnum:]])set_gdbarch_read_pc[[:space:]]*\(/ || \ 958/(^|[^_[:alnum:]])TARGET_READ_PC[[:space:]]*\(/ { 959 fail("read_pc") 960} 961 962BEGIN { doc["write_pc"] = "\ 963Replace write_pc() with get_frame_base_address or get_frame_id; \ 964at present the inferior function call code still uses this when doing \ 965a DECR_PC_AFTER_BREAK" 966 category["write_pc"] = ari_deprecate 967} 968/(^|[^_[:alnum:]])write_pc[[:space:]]*\(/ || \ 969/(^|[^_[:alnum:]])TARGET_WRITE_PC[[:space:]]*\(/ { 970 fail("write_pc") 971} 972 973BEGIN { doc["generic_target_write_pc"] = "\ 974Replace generic_target_write_pc with a per-architecture implementation, \ 975this relies on PC_REGNUM which is being eliminated" 976 category["generic_target_write_pc"] = ari_regression 977} 978/(^|[^_[:alnum:]])generic_target_write_pc([^_[:alnum:]]|$)/ { 979 fail("generic_target_write_pc") 980} 981 982BEGIN { doc["read_sp"] = "\ 983Replace read_sp() with frame_sp_unwind" 984 category["read_sp"] = ari_regression 985} 986/(^|[^_[:alnum:]])read_sp[[:space:]]*\(/ || \ 987/(^|[^_[:alnum:]])set_gdbarch_read_sp[[:space:]]*\(/ || \ 988/(^|[^_[:alnum:]])TARGET_READ_SP[[:space:]]*\(/ { 989 fail("read_sp") 990} 991 992BEGIN { doc["register_cached"] = "\ 993Replace register_cached() with nothing, does not have a regcache parameter" 994 category["register_cached"] = ari_regression 995} 996/(^|[^_[:alnum:]])register_cached[[:space:]]*\(/ { 997 fail("register_cached") 998} 999 1000BEGIN { doc["set_register_cached"] = "\ 1001Replace set_register_cached() with nothing, does not have a regcache parameter" 1002 category["set_register_cached"] = ari_regression 1003} 1004/(^|[^_[:alnum:]])set_register_cached[[:space:]]*\(/ { 1005 fail("set_register_cached") 1006} 1007 1008# Print functions: Use versions that either check for buffer overflow 1009# or safely allocate a fresh buffer. 1010 1011BEGIN { doc["sprintf"] = "\ 1012Do not use sprintf, instead use xsnprintf or xstrprintf" 1013 category["sprintf"] = ari_code 1014} 1015/(^|[^_[:alnum:]])sprintf[[:space:]]*\(/ { 1016 fail("sprintf") 1017} 1018 1019BEGIN { doc["vsprintf"] = "\ 1020Do not use vsprintf(), instead use xstrvprintf" 1021 category["vsprintf"] = ari_regression 1022} 1023/(^|[^_[:alnum:]])vsprintf[[:space:]]*\(/ { 1024 fail("vsprintf") 1025} 1026 1027BEGIN { doc["asprintf"] = "\ 1028Do not use asprintf(), instead use xstrprintf()" 1029 category["asprintf"] = ari_regression 1030} 1031/(^|[^_[:alnum:]])asprintf[[:space:]]*\(/ { 1032 fail("asprintf") 1033} 1034 1035BEGIN { doc["vasprintf"] = "\ 1036Do not use vasprintf(), instead use xstrvprintf" 1037 fix("vasprintf", "gdbsupport/common-utils.c", 1) 1038 category["vasprintf"] = ari_regression 1039} 1040/(^|[^_[:alnum:]])vasprintf[[:space:]]*\(/ { 1041 fail("vasprintf") 1042} 1043 1044BEGIN { doc["printf_vma"] = "\ 1045Do not use printf_vma, instead use paddress or phex_nz" 1046 category["printf_vma"] = ari_code 1047} 1048/(^|[^_[:alnum:]])printf_vma[[:space:]]*\(/ { 1049 fail("printf_vma") 1050} 1051 1052BEGIN { doc["sprintf_vma"] = "\ 1053Do not use sprintf_vma, instead use paddress or phex_nz" 1054 category["sprintf_vma"] = ari_code 1055} 1056/(^|[^_[:alnum:]])sprintf_vma[[:space:]]*\(/ { 1057 fail("sprintf_vma") 1058} 1059 1060# More generic memory operations 1061 1062BEGIN { doc["bzero"] = "\ 1063Do not use bzero(), instead use memset()" 1064 category["bzero"] = ari_regression 1065} 1066/(^|[^_[:alnum:]])bzero[[:space:]]*\(/ { 1067 fail("bzero") 1068} 1069 1070BEGIN { doc["strdup"] = "\ 1071Do not use strdup(), instead use xstrdup()"; 1072 category["strdup"] = ari_regression 1073} 1074/(^|[^_[:alnum:]])strdup[[:space:]]*\(/ { 1075 fail("strdup") 1076} 1077 1078BEGIN { doc["strsave"] = "\ 1079Do not use strsave(), instead use xstrdup() et.al." 1080 category["strsave"] = ari_regression 1081} 1082/(^|[^_[:alnum:]])strsave[[:space:]]*\(/ { 1083 fail("strsave") 1084} 1085 1086# String compare functions 1087 1088BEGIN { doc["strnicmp"] = "\ 1089Do not use strnicmp(), instead use strncasecmp()" 1090 category["strnicmp"] = ari_regression 1091} 1092/(^|[^_[:alnum:]])strnicmp[[:space:]]*\(/ { 1093 fail("strnicmp") 1094} 1095 1096# Typedefs that are either redundant or can be reduced to `struct 1097# type *''. 1098# Must be placed before if assignment otherwise ARI exceptions 1099# are not handled correctly. 1100 1101BEGIN { doc["d_namelen"] = "\ 1102Do not use dirent.d_namelen, instead use NAMELEN" 1103 category["d_namelen"] = ari_regression 1104} 1105/(^|[^_[:alnum:]])d_namelen([^_[:alnum:]]|$)/ { 1106 fail("d_namelen") 1107} 1108 1109BEGIN { doc["strlen d_name"] = "\ 1110Do not use strlen dirent.d_name, instead use NAMELEN" 1111 category["strlen d_name"] = ari_regression 1112} 1113/(^|[^_[:alnum:]])strlen[[:space:]]*\(.*[^_[:alnum:]]d_name([^_[:alnum:]]|$)/ { 1114 fail("strlen d_name") 1115} 1116 1117BEGIN { doc["generic_use_struct_convention"] = "\ 1118Replace generic_use_struct_convention with nothing, \ 1119EXTRACT_STRUCT_VALUE_ADDRESS is a predicate" 1120 category["generic_use_struct_convention"] = ari_regression 1121} 1122/(^|[^_[:alnum:]])generic_use_struct_convention([^_[:alnum:]]|$)/ { 1123 fail("generic_use_struct_convention") 1124} 1125 1126BEGIN { doc["if assignment"] = "\ 1127An IF statement'\''s expression contains an assignment (the GNU coding \ 1128standard discourages this)" 1129 category["if assignment"] = ari_code 1130} 1131BEGIN { doc["if clause more than 50 lines"] = "\ 1132An IF statement'\''s expression expands over 50 lines" 1133 category["if clause more than 50 lines"] = ari_code 1134} 1135# 1136# Accumulate continuation lines 1137FNR == 1 { 1138 in_if = 0 1139} 1140 1141/(^|[^_[:alnum:]])if / { 1142 in_if = 1; 1143 if_brace_level = 0; 1144 if_cont_p = 0; 1145 if_count = 0; 1146 if_brace_end_pos = 0; 1147 if_full_line = ""; 1148} 1149(in_if) { 1150 # We want everything up to closing brace of same level 1151 if_count++; 1152 if (if_count > 50) { 1153 print "multiline if: " if_full_line $0 1154 fail("if clause more than 50 lines") 1155 if_brace_level = 0; 1156 if_full_line = ""; 1157 } else { 1158 if (if_count == 1) { 1159 i = index($0,"if "); 1160 } else { 1161 i = 1; 1162 } 1163 for (i=i; i <= length($0); i++) { 1164 char = substr($0,i,1); 1165 if (char == "(") { if_brace_level++; } 1166 if (char == ")") { 1167 if_brace_level--; 1168 if (!if_brace_level) { 1169 if_brace_end_pos = i; 1170 after_if = substr($0,i+1,length($0)); 1171 # Do not parse what is following 1172 break; 1173 } 1174 } 1175 } 1176 if (if_brace_level == 0) { 1177 $0 = substr($0,1,i); 1178 in_if = 0; 1179 } else { 1180 if_full_line = if_full_line $0; 1181 if_cont_p = 1; 1182 next; 1183 } 1184 } 1185} 1186# if we arrive here, we need to concatenate, but we are at brace level 0 1187 1188(if_brace_end_pos) { 1189 $0 = if_full_line substr($0,1,if_brace_end_pos); 1190 if (if_count > 1) { 1191 # print "IF: multi line " if_count " found at " FILENAME ":" FNR " \"" $0 "\"" 1192 } 1193 if_cont_p = 0; 1194 if_full_line = ""; 1195} 1196/(^|[^_[:alnum:]])if .* = / { 1197 # print "fail in if " $0 1198 fail("if assignment") 1199} 1200(if_brace_end_pos) { 1201 $0 = $0 after_if; 1202 if_brace_end_pos = 0; 1203 in_if = 0; 1204} 1205 1206# Printout of all found bug 1207 1208BEGIN { 1209 if (print_doc) { 1210 for (bug in doc) { 1211 fail(bug) 1212 } 1213 exit 1214 } 1215}' "$@" 1216 1217