florian | 033e7a6 | 2014-12-03 22:48:29 +0000 | [diff] [blame] | 1 | #!/usr/bin/env perl |
| 2 | |
| 3 | # Lame script to compare two build logs. |
| 4 | # |
| 5 | # The script intercepts directory changes and compiler invocations and |
| 6 | # compares the compiler invocations for equality. Equality is defined |
| 7 | # as "same options in both invocations ignoring order". So we only test |
| 8 | # a necessary condition. |
| 9 | # |
| 10 | # Both builds must be configured with the same --prefix. Otherwise, |
| 11 | # the value of -DVG_LIBDIR= will differ. They also need to use the same |
| 12 | # compiler. |
| 13 | |
| 14 | use Getopt::Long; |
| 15 | use strict; |
| 16 | use warnings; |
| 17 | |
| 18 | my $prog_name = "compare-build-logs"; |
| 19 | |
| 20 | my $usage=<<EOF; |
| 21 | USAGE |
| 22 | |
| 23 | $prog_name log1 log2 |
| 24 | |
| 25 | [--gcc] intercept GCC invocations (this is default) |
| 26 | |
| 27 | [--clang] intercept clang invocations |
| 28 | |
| 29 | [-v] verbose mode |
| 30 | |
| 31 | log-file1 |
| 32 | |
| 33 | log-file2 |
| 34 | EOF |
| 35 | |
| 36 | my $compiler = "gcc"; |
| 37 | my $verbose = 0; |
| 38 | |
| 39 | GetOptions( "gcc" => sub { $compiler = "gcc" }, |
| 40 | "clang" => sub { $compiler = "clang" }, |
| 41 | "v" => sub { $verbose = 1 }, |
| 42 | ) || die $usage; |
| 43 | |
| 44 | my $num_arg = $#ARGV + 1; |
| 45 | |
| 46 | if ($num_arg != 2) { |
| 47 | die $usage; |
| 48 | } |
| 49 | |
| 50 | my $log1 = $ARGV[0]; |
| 51 | my $log2 = $ARGV[1]; |
| 52 | |
| 53 | # Hashes: relative filename -> compiler invocation |
| 54 | my %cmd1 = read_log_file($log1); |
| 55 | my %cmd2 = read_log_file($log2); |
| 56 | |
| 57 | # Compare the log files |
| 58 | |
| 59 | foreach my $file (keys %cmd1) { |
| 60 | if (! $cmd2{$file}) { |
| 61 | print "*** $file missing in $log2\n"; |
| 62 | } else { |
| 63 | compare_invocations($file, $cmd1{$file }, $cmd2{$file}); |
| 64 | } |
| 65 | } |
| 66 | foreach my $file (keys %cmd2) { |
| 67 | if (! $cmd1{$file}) { |
| 68 | print "*** $file missing in $log1\n"; |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | exit 0; |
| 73 | |
| 74 | # Compare two lines |c1| and |c2| which are compiler invocations for |file|. |
| 75 | # Basically, we look at a compiler invocation as a sequence of blank-separated |
| 76 | # options. |
| 77 | sub compare_invocations { |
| 78 | my ($file, $c1, $c2) = @_; |
| 79 | my ($found1, $found2); |
| 80 | # print "COMPARE $file\n"; |
| 81 | |
| 82 | # Remove stuff that has embedded spaces |
| 83 | |
| 84 | # Remove: `test -f 'whatever.c' || echo './'` |
| 85 | $c1 =~ s|(`[^`]*`)||; |
| 86 | $found1 = $1; |
| 87 | $c2 =~ s|(`[^`]*`)||; |
| 88 | $found2 = $1; |
| 89 | if ($found1 && $found2) { |
| 90 | die if ($found1 ne $found2); |
| 91 | } |
| 92 | |
| 93 | # Remove: -o whatever |
| 94 | $c1 =~ s|-o[ ][ ]*([^ ][^ ]*)||; |
| 95 | $found1 = $1; |
| 96 | $c2 =~ s|-o[ ][ ]*([^ ][^ ]*)||; |
| 97 | $found2 = $1; |
| 98 | if ($found1 && $found2) { |
| 99 | die if ($found1 ne $found2); |
| 100 | } |
| 101 | |
| 102 | # The remaining lines are considered to be blank-separated options and file |
| 103 | # names. They should be identical in both invocations (but in any order). |
| 104 | my %o1 = (); |
| 105 | my %o2 = (); |
| 106 | foreach my $k (split /\s+/,$c1) { |
| 107 | $o1{$k} = 1; |
| 108 | } |
| 109 | foreach my $k (split /\s+/,$c2) { |
| 110 | $o2{$k} = 1; |
| 111 | } |
| 112 | # foreach my $zz (keys %o1) { |
| 113 | # print "$zz\n"; |
| 114 | # } |
| 115 | foreach my $k (keys %o1) { |
| 116 | if (! $o2{$k}) { |
| 117 | print "*** '$k' is missing in compilation of '$file' in $log2\n"; |
| 118 | } |
| 119 | } |
| 120 | foreach my $k (keys %o2) { |
| 121 | if (! $o1{$k}) { |
| 122 | print "*** '$k' is missing in compilation of '$file' in $log1\n"; |
| 123 | } |
| 124 | } |
| 125 | } |
| 126 | |
| 127 | # Read a compiler log file. |
| 128 | # Return hash: relative (to build root) file name -> compiler invocation |
| 129 | sub read_log_file |
| 130 | { |
| 131 | my ($log) = @_; |
| 132 | my $dir = ""; |
| 133 | my $root = ""; |
| 134 | my %cmd = (); |
| 135 | |
| 136 | print "...reading $log\n" if ($verbose); |
| 137 | |
| 138 | open(LOG, "$log") || die "cannot open $log\n"; |
| 139 | while (my $line = <LOG>) { |
| 140 | chomp $line; |
| 141 | if ($line =~ /^make/) { |
| 142 | if ($line =~ /Entering directory/) { |
| 143 | $dir = $line; |
| 144 | $dir =~ s/^.*`//; |
| 145 | $dir =~ s/'.*//; |
| 146 | if ($root eq "") { |
| 147 | $root = $dir; |
| 148 | # Append a slash if not present |
| 149 | $root = "$root/" if (! ($root =~ /\/$/)); |
| 150 | print "...build root is $root\n" if ($verbose); |
| 151 | } |
| 152 | # print "DIR = $dir\n"; |
| 153 | next; |
| 154 | } |
| 155 | } |
| 156 | if ($line =~ /^\s*[^\s]*$compiler\s/) { |
| 157 | # If line ends in \ read continuation line. |
| 158 | while ($line =~ /\\$/) { |
| 159 | my $next = <LOG>; |
| 160 | chomp($next); |
| 161 | $line =~ s/\\$//; |
| 162 | $line .= $next; |
| 163 | } |
| 164 | |
| 165 | my $file = extract_file($line); |
| 166 | $file = "$dir/$file"; # make absolute |
| 167 | $file =~ s/$root//; # remove build root |
| 168 | # print "FILE $file\n"; |
| 169 | $cmd{"$file"} = $line; |
| 170 | } |
| 171 | } |
| 172 | close(LOG); |
| 173 | |
| 174 | my $num_invocations = int(keys %cmd); |
| 175 | |
| 176 | if ($num_invocations == 0) { |
| 177 | print "*** File $log does not contain any compiler invocations\n"; |
| 178 | } else { |
| 179 | print "...found $num_invocations invocations\n" if ($verbose); |
| 180 | } |
| 181 | return %cmd; |
| 182 | } |
| 183 | |
| 184 | # Extract a file name from the command line. Assume there is a -o filename |
| 185 | # present. If not, issue a warning. |
| 186 | # |
| 187 | sub extract_file { |
| 188 | my($line) = @_; |
| 189 | # Look for -o executable |
| 190 | if ($line =~ /-o[ ][ ]*([^ ][^ ]*)/) { |
| 191 | return $1; |
| 192 | } else { |
| 193 | print "*** Could not extract file name from $line\n"; |
| 194 | return "UNKNOWN"; |
| 195 | } |
| 196 | } |