tests/check_headers_and_includes

   1 #!/usr/bin/env perl
   2
   3 #-------------------------------------------------------------------
   4 # Check header files and #include directives
   5 #
   6 # (1) include/*.h must not include pub_core_...h
   7 # (2) coregrind/pub_core_xyzzy.h may include pub_tool_xyzzy.h
   8 #     other coregrind headers may not include pub_tool_xyzzy.h
   9 # (3) coregrind/ *.c must not include pub_tool_xyzzy.h
  10 # (4) tool *.[ch] files must not include pub_core_...h
  11 # (5) include pub_core/tool_clreq.h instead of valgrind.h except in tools'
  12 #     export headers
  13 # (6) coregrind/ *.[ch] must not use tl_assert
  14 # (7) include/*.h and tool *.[ch] must not use vg_assert
  15 # (8) coregrind/ *.[ch] must not use VG_(tool_panic)
  16 # (9) include/*.h and tool *.[ch] must not use VG_(core_panic)
  17 # (10) *.S must unconditionally instantiate MARK_STACK_NO_EXEC
  18 #
  19 # There can be false positives as we don't really parse the source files.
  20 # Instead we only match regular expressions.
  21 #-------------------------------------------------------------------
  22
  23 use strict;
  24 use warnings;
  25 use File::Basename;
  26 use Getopt::Long;
  27
  28 my $this_script = basename($0);
  29
  30 # The list of top-level directories is divided into three sets:
  31 #
  32 # (1) coregrind directories
  33 # (2) tool directories
  34 # (3) directories to ignore
  35 #
  36 # If a directory is found that does not belong to any of those sets, the
  37 # script will terminate unsuccessfully.
  38
  39 my %coregrind_dirs = (
  40     "include" => 1,
  41     "coregrind" => 1,
  42     );
  43
  44 my %tool_dirs = (
  45     "none" => 1,
  46     "lackey" => 1,
  47     "massif" => 1,
  48     "memcheck" => 1,
  49     "drd" => 1,
  50     "helgrind", => 1,
  51     "callgrind" => 1,
  52     "cachegrind" => 1,
  53     "shared" => 1,
  54     "exp-bbv" => 1,
  55     "exp-dhat" => 1,
  56     "exp-sgcheck" => 1
  57     );
  58
  59 my %dirs_to_ignore = (
  60     ".deps" => 1,
  61     ".svn" => 1,
  62     ".git" => 1,            # allow git mirrors of the svn repo
  63     ".in_place" => 1,
  64     "Inst" => 1,            # the nightly scripts creates this
  65     "VEX" => 1,
  66     "docs" => 1,
  67     "auxprogs" => 1,
  68     "autom4te.cache" => 1,
  69     "nightly" => 1,
  70     "perf" => 1,
  71     "tests" => 1,
  72     "gdbserver_tests" => 1,
  73     "mpi" => 1,
  74     "solaris" => 1
  75     );
  76
  77 my %tool_export_header = (
  78     "drd/drd.h" => 1,
  79     "helgrind/helgrind.h" => 1,
  80     "memcheck/memcheck.h" => 1,
  81     "callgrind/callgrind.h" => 1
  82     );
  83
  84 my $usage=<<EOF;
  85 USAGE
  86
  87   $this_script
  88
  89     [--debug]          Debugging output
  90
  91     dir ...            Directories to process
  92 EOF
  93
  94 my $debug = 0;
  95 my $num_errors = 0;
  96
  97 &main;
  98
  99 sub main {
 100     GetOptions( "debug"  => \$debug ) || die $usage;
 101
 102     my $argc = $#ARGV + 1;
 103
 104     if ($argc < 1) {
 105         die $usage;
 106     }
 107
 108     foreach my $dir (@ARGV) {
 109         process_dir(undef, $dir, 0);
 110     }
 111
 112     my $rc = ($num_errors == 0) ? 0 : 1;
 113     exit $rc;
 114 }
 115
 116 sub process_dir {
 117     my ($path, $dir, $depth) = @_;
 118     my $hdir;
 119
 120     if ($depth == 0) {
 121 # The root directory is always processed
 122     } elsif ($depth == 1) {
 123 # Toplevel directories
 124         return if ($dirs_to_ignore{$dir});
 125
 126         if (! $tool_dirs{$dir} && ! $coregrind_dirs{$dir}) {
 127             die "Unknown directory '$dir'. Please update $this_script\n";
 128         }
 129     } else {
 130 # Subdirectories
 131         return if ($dirs_to_ignore{$dir});
 132     }
 133
 134     print "DIR = $dir   DEPTH = $depth\n" if ($debug);
 135
 136     chdir($dir) || die "Cannot chdir '$dir'\n";
 137
 138     opendir($hdir, ".") || die "cannot open directory '.'";
 139
 140     while (my $file = readdir($hdir)) {
 141         next if ($file eq ".");
 142         next if ($file eq "..");
 143
 144 # Subdirectories
 145         if (-d $file) {
 146             my $full_path = defined $path ? "$path/$file" : $file;
 147             process_dir($full_path, $file, $depth + 1);
 148             next;
 149         }
 150
 151 # Regular files; only interested in *.c, *.S and *.h
 152         next if (! ($file =~ /\.[cSh]$/));
 153         my $path_name = defined $path ? "$path/$file" : $file;
 154         process_file($path_name);
 155     }
 156     close($hdir);
 157     chdir("..") || die "Cannot chdir '..'\n";
 158 }
 159
 160 #---------------------------------------------------------------------
 161 # Return 1, if file is located in <valgrind>/include
 162 #---------------------------------------------------------------------
 163 sub is_coregrind_export_header {
 164     my ($path_name) = @_;
 165
 166     return ($path_name =~ /^include\//) ? 1 : 0;
 167 }
 168
 169 #---------------------------------------------------------------------
 170 # Return 1, if file is located underneath <valgrind>/coregrind
 171 #---------------------------------------------------------------------
 172 sub is_coregrind_file {
 173     my ($path_name) = @_;
 174
 175     return ($path_name =~ /^coregrind\//) ? 1 : 0;
 176 }
 177
 178 #---------------------------------------------------------------------
 179 # Return 1, if file is located underneath <valgrind>/<tool>
 180 #---------------------------------------------------------------------
 181 sub is_tool_file {
 182     my ($path_name) = @_;
 183
 184     for my $tool (keys %tool_dirs) {
 185         return 1 if ($path_name =~ /^$tool\//);
 186     }
 187     return 0
 188 }
 189
 190 #---------------------------------------------------------------------
 191 # Return array of files #include'd by file.
 192 #---------------------------------------------------------------------
 193 sub get_included_files {
 194     my ($path_name) = @_;
 195     my @includes = ();
 196     my $file = basename($path_name);
 197
 198     open(FILE, "<$file") || die "Cannot open file '$file'";
 199
 200     while (my $line = <FILE>) {
 201         if ($line =~ /^\s*#\s*include "([^"]*)"/) {
 202             push @includes, $1;
 203         }
 204         if ($line =~ /^\s*#\s*include <([^>]*)>/) {
 205             push @includes, $1;
 206         }
 207     }
 208     close FILE;
 209     return @includes;
 210 }
 211
 212 #---------------------------------------------------------------------
 213 # Check a file from <valgrind>/include
 214 #---------------------------------------------------------------------
 215 sub check_coregrind_export_header {
 216     my ($path_name) = @_;
 217     my $file = basename($path_name);
 218
 219     foreach my $inc (get_included_files($path_name)) {
 220         $inc = basename($inc);
 221 # Must not include pub_core_....
 222         if ($inc =~ /pub_core_/) {
 223             error("File $path_name must not include $inc\n");
 224         }
 225 # Only pub_tool_clreq.h may include valgrind.h
 226         if (($inc eq "valgrind.h") && ($path_name ne "include/pub_tool_clreq.h")) {
 227             error("File $path_name should include pub_tool_clreq.h instead of $inc\n");
 228         }
 229     }
 230 # Must not use vg_assert
 231     my $assert = `grep vg_assert $file`;
 232     if ($assert ne "") {
 233         error("File $path_name must not use vg_assert\n");
 234     }
 235 # Must not use VG_(core_panic)
 236     my $panic = `grep 'VG_(core_panic)' $file`;
 237     if ($panic ne "") {
 238         error("File $path_name must not use VG_(core_panic)\n");
 239     }
 240 }
 241
 242 #---------------------------------------------------------------------
 243 # Check a file from <valgrind>/coregrind
 244 #---------------------------------------------------------------------
 245 sub check_coregrind_file {
 246     my ($path_name) = @_;
 247     my $file = basename($path_name);
 248
 249     foreach my $inc (get_included_files($path_name)) {
 250         print "\tINCLUDE $inc\n" if ($debug);
 251 # Only pub_tool_xyzzy.h may include pub_core_xyzzy.h
 252         if ($inc =~ /pub_tool_/) {
 253             my $buddy = $inc;
 254             $buddy =~ s/pub_tool/pub_core/;
 255             if ($file ne $buddy) {
 256                 error("File $path_name must not include $inc\n");
 257             }
 258         }
 259 # Must not include valgrind.h
 260         if ($inc eq "valgrind.h") {
 261             error("File $path_name should include pub_core_clreq.h instead of $inc\n");
 262         }
 263     }
 264 # Must not use tl_assert
 265     my $assert = `grep tl_assert $file`;
 266     if ($assert ne "") {
 267         error("File $path_name must not use tl_assert\n");
 268     }
 269 # Must not use VG_(tool_panic)
 270     my $panic = `grep 'VG_(tool_panic)' $file`;
 271     if ($panic ne "") {
 272         chomp($panic);
 273 # Do not complain about the definition of VG_(tool_panic)
 274         if (($path_name eq "coregrind/m_libcassert.c") &&
 275             ($panic eq "void VG_(tool_panic) ( const HChar* str )")) {
 276 # OK
 277         } else {
 278             error("File $path_name must not use VG_(tool_panic)\n");
 279         }
 280     }
 281 }
 282
 283 #---------------------------------------------------------------------
 284 # Check a file from <valgrind>/<tool>
 285 #---------------------------------------------------------------------
 286 sub check_tool_file {
 287     my ($path_name) = @_;
 288     my $file = basename($path_name);
 289
 290     foreach my $inc (get_included_files($path_name)) {
 291         print "\tINCLUDE $inc\n" if ($debug);
 292 # Must not include pub_core_...
 293         if ($inc =~ /pub_core_/) {
 294             error("File $path_name must not include $inc\n");
 295         }
 296 # Must not include valgrind.h unless this is an export header
 297         if ($inc eq "valgrind.h" && ! $tool_export_header{$path_name}) {
 298             error("File $path_name should include pub_tool_clreq.h instead of $inc\n");
 299         }
 300     }
 301 # Must not use vg_assert
 302     my $assert = `grep vg_assert $file`;
 303     if ($assert ne "") {
 304         error("File $path_name must not use vg_assert\n");
 305     }
 306 # Must not use VG_(core_panic)
 307     my $panic = `grep 'VG_(core_panic)' $file`;
 308     if ($panic ne "") {
 309         error("File $path_name must not use VG_(core_panic)\n");
 310     }
 311 }
 312
 313 #---------------------------------------------------------------------
 314 # Check an assembler file
 315 #---------------------------------------------------------------------
 316 sub check_assembler_file {
 317     my ($path_name) = @_;
 318     my $file = basename($path_name);
 319     my $found = 0;
 320
 321     open(FILE, "<$file") || die "Cannot open file '$file'";
 322
 323     while (my $line = <FILE>) {
 324         if ($line =~ /^\s*MARK_STACK_NO_EXEC/) {
 325             $found = 1;
 326             last;
 327         }
 328     }
 329     if ($found == 0) {
 330         error("File $path_name does not instantiate MARK_STACK_NO_EXEC\n");
 331     } else {
 332         while (my $line = <FILE>) {
 333             if ($line =~ /^\s*#\s*endif/) {
 334                 error("File $path_name instantiates MARK_STACK_NO_EXEC"
 335                       . " under a condition\n");
 336                 last;
 337             }
 338         }
 339     }
 340     close FILE;
 341 }
 342
 343 sub process_file {
 344     my ($path_name) = @_;
 345
 346     print "FILE = $path_name\n" if ($debug);
 347
 348     if (is_coregrind_export_header($path_name)) {
 349         check_coregrind_export_header($path_name);
 350     } elsif (is_coregrind_file($path_name)) {
 351         check_coregrind_file($path_name);
 352     } elsif (is_tool_file($path_name)) {
 353         check_tool_file($path_name);
 354     }
 355
 356     if ($path_name =~ /\.S$/) {
 357         check_assembler_file($path_name);
 358     }
 359 }
 360
 361 sub error {
 362     my ($message) = @_;
 363     print STDERR "*** $message";
 364     ++$num_errors;
 365 }