ccc-analyzer revision 71f11d6a393c185b8896d3f6a4089ef93d340d00 
1#!/usr/bin/env perl
2#
3#                     The LLVM Compiler Infrastructure
4#
5# This file is distributed under the University of Illinois Open Source
6# License. See LICENSE.TXT for details.
7#
8##===----------------------------------------------------------------------===##
9#
10#  A script designed to interpose between the build system and gcc.  It invokes
11#  both gcc and the static analyzer.
12#
13##===----------------------------------------------------------------------===##
14
15use strict;
16use warnings;
17use FindBin;
18use Cwd qw/ getcwd abs_path /;
19use File::Temp qw/ tempfile /;
20use File::Path qw / mkpath /;
21use File::Basename;
22use Text::ParseWords;
23
24##===----------------------------------------------------------------------===##
25# Compiler command setup.
26##===----------------------------------------------------------------------===##
27
28my $Compiler;
29my $Clang;
30
31if ($FindBin::Script =~ /c\+\+-analyzer/) {
32  $Compiler = $ENV{'CCC_CXX'};
33  if (!defined $Compiler) { $Compiler = "g++"; }
34  
35  $Clang = $ENV{'CLANG_CXX'};
36  if (!defined $Clang) { $Clang = 'clang++'; }
37}
38else {
39  $Compiler = $ENV{'CCC_CC'};
40  if (!defined $Compiler) { $Compiler = "gcc"; }
41
42  $Clang = $ENV{'CLANG'};
43  if (!defined $Clang) { $Clang = 'clang'; }
44}
45
46##===----------------------------------------------------------------------===##
47# Cleanup.
48##===----------------------------------------------------------------------===##
49
50my $ReportFailures = $ENV{'CCC_REPORT_FAILURES'};
51if (!defined $ReportFailures) { $ReportFailures = 1; }
52
53my $CleanupFile;
54my $ResultFile;
55
56# Remove any stale files at exit.
57END { 
58  if (defined $CleanupFile && -z $CleanupFile) {
59    `rm -f $CleanupFile`;
60  }
61}
62
63##----------------------------------------------------------------------------##
64#  Process Clang Crashes.
65##----------------------------------------------------------------------------##
66
67sub GetPPExt {
68  my $Lang = shift;
69  if ($Lang =~ /objective-c\+\+/) { return ".mii" };
70  if ($Lang =~ /objective-c/) { return ".mi"; }
71  if ($Lang =~ /c\+\+/) { return ".ii"; }
72  return ".i";
73}
74
75# Set this to 1 if we want to include 'parser rejects' files.
76my $IncludeParserRejects = 0;
77my $ParserRejects = "Parser Rejects";
78
79my $AttributeIgnored = "Attribute Ignored";
80
81sub ProcessClangFailure {
82  my ($Clang, $Lang, $file, $Args, $HtmlDir, $ErrorType, $ofile) = @_;
83  my $Dir = "$HtmlDir/failures";
84  mkpath $Dir;
85  
86  my $prefix = "clang_crash";
87  if ($ErrorType eq $ParserRejects) {
88    $prefix = "clang_parser_rejects";
89  }
90  elsif ($ErrorType eq $AttributeIgnored) {
91    $prefix = "clang_attribute_ignored";
92  }
93
94  # Generate the preprocessed file with Clang.
95  my ($PPH, $PPFile) = tempfile( $prefix . "_XXXXXX",
96                                 SUFFIX => GetPPExt($Lang),
97                                 DIR => $Dir);
98  system $Clang, @$Args, "-E", "-o", $PPFile;
99  close ($PPH);
100  
101  # Create the info file.
102  open (OUT, ">", "$PPFile.info.txt") or die "Cannot open $PPFile.info.txt\n";
103  print OUT abs_path($file), "\n";
104  print OUT "$ErrorType\n";
105  print OUT "@$Args\n";
106  close OUT;
107  `uname -a >> $PPFile.info.txt 2>&1`;
108  `$Compiler -v >> $PPFile.info.txt 2>&1`;
109  system 'mv',$ofile,"$PPFile.stderr.txt";
110  return (basename $PPFile);
111}
112
113##----------------------------------------------------------------------------##
114#  Running the analyzer.
115##----------------------------------------------------------------------------##
116
117sub GetCCArgs {
118  my $mode = shift;
119  my $Args = shift;
120  
121  pipe (FROM_CHILD, TO_PARENT);
122  my $pid = fork();
123  if ($pid == 0) {
124    close FROM_CHILD;
125    open(STDOUT,">&", \*TO_PARENT);
126    open(STDERR,">&", \*TO_PARENT);
127    exec $Clang, "-###", $mode, @$Args;
128  }  
129  close(TO_PARENT);
130  my $line;
131  while (<FROM_CHILD>) {
132    next if (!/-cc1/);
133    $line = $_;
134  }
135
136  waitpid($pid,0);
137  close(FROM_CHILD);
138  
139  die "could not find clang line\n" if (!defined $line);
140  # Strip the newline and initial whitspace
141  chomp $line;
142  $line =~ s/^\s+//;
143  my @items = quotewords('\s+', 0, $line);
144  my $cmd = shift @items;
145  die "cannot find 'clang' in 'clang' command\n" if (!($cmd =~ /clang/));
146  return \@items;
147}
148
149sub Analyze {
150  my ($Clang, $OriginalArgs, $AnalyzeArgs, $Lang, $Output, $Verbose, $HtmlDir,
151      $file) = @_;
152
153  my @Args = @$OriginalArgs;
154  my $Cmd;
155  my @CmdArgs;
156  my @CmdArgsSansAnalyses;
157
158  if ($Lang =~ /header/) {
159    exit 0 if (!defined ($Output));
160    $Cmd = 'cp';
161    push @CmdArgs, $file;
162    # Remove the PCH extension.
163    $Output =~ s/[.]gch$//;
164    push @CmdArgs, $Output;
165    @CmdArgsSansAnalyses = @CmdArgs;
166  }
167  else {
168    $Cmd = $Clang;
169    if ($Lang eq "objective-c" || $Lang eq "objective-c++") {
170      push @Args,'-DIBOutlet=__attribute__((iboutlet))';
171      push @Args,'-DIBOutletCollection(ClassName)=__attribute__((iboutletcollection)))';
172      push @Args,'-DIBAction=void)__attribute__((ibaction)';
173    }
174
175    # Create arguments for doing regular parsing.
176    my $SyntaxArgs = GetCCArgs("-fsyntax-only", \@Args);
177    @CmdArgsSansAnalyses = @$SyntaxArgs;
178
179    # Create arguments for doing static analysis.
180    if (defined $ResultFile) {
181      push @Args, '-o', $ResultFile;
182    }
183    elsif (defined $HtmlDir) {
184      push @Args, '-o', $HtmlDir;
185    }
186    if ($Verbose) {
187      push @Args, "-Xclang", "-analyzer-display-progress";
188    }
189
190    foreach my $arg (@$AnalyzeArgs) {
191      push @Args, "-Xclang", $arg;
192    }
193
194    # Display Ubiviz graph?
195    if (defined $ENV{'CCC_UBI'}) {   
196      push @Args, "-Xclang", "-analyzer-viz-egraph-ubigraph";
197    }
198
199    my $AnalysisArgs = GetCCArgs("--analyze", \@Args);
200    @CmdArgs = @$AnalysisArgs;
201  }
202
203  my @PrintArgs;
204  my $dir;
205
206  if ($Verbose) {
207    $dir = getcwd();
208    print STDERR "\n[LOCATION]: $dir\n";
209    push @PrintArgs,"'$Cmd'";
210    foreach my $arg (@CmdArgs) {
211        push @PrintArgs,"\'$arg\'";
212    }
213  }
214  if ($Verbose == 1) {
215    # We MUST print to stderr.  Some clients use the stdout output of
216    # gcc for various purposes. 
217    print STDERR join(' ', @PrintArgs);
218    print STDERR "\n";
219  }
220  elsif ($Verbose == 2) {
221    print STDERR "#SHELL (cd '$dir' && @PrintArgs)\n";
222  }
223
224  # Capture the STDERR of clang and send it to a temporary file.
225  # Capture the STDOUT of clang and reroute it to ccc-analyzer's STDERR.
226  # We save the output file in the 'crashes' directory if clang encounters
227  # any problems with the file.  
228  pipe (FROM_CHILD, TO_PARENT);
229  my $pid = fork();
230  if ($pid == 0) {
231    close FROM_CHILD;
232    open(STDOUT,">&", \*TO_PARENT);
233    open(STDERR,">&", \*TO_PARENT);
234    exec $Cmd, @CmdArgs;
235  }
236
237  close TO_PARENT;
238  my ($ofh, $ofile) = tempfile("clang_output_XXXXXX", DIR => $HtmlDir);
239  
240  while (<FROM_CHILD>) {
241    print $ofh $_;
242    print STDERR $_;
243  }
244
245  waitpid($pid,0);
246  close(FROM_CHILD);
247  my $Result = $?;
248
249  # Did the command die because of a signal?
250  if ($ReportFailures) {
251    if ($Result & 127 and $Cmd eq $Clang and defined $HtmlDir) {
252      ProcessClangFailure($Clang, $Lang, $file, \@CmdArgsSansAnalyses,
253                          $HtmlDir, "Crash", $ofile);
254    }
255    elsif ($Result) {
256      if ($IncludeParserRejects && !($file =~/conftest/)) {
257        ProcessClangFailure($Clang, $Lang, $file, \@CmdArgsSansAnalyses,
258                            $HtmlDir, $ParserRejects, $ofile);
259      }
260    }
261    else {
262      # Check if there were any unhandled attributes.
263      if (open(CHILD, $ofile)) {
264        my %attributes_not_handled;
265
266        # Don't flag warnings about the following attributes that we
267        # know are currently not supported by Clang.
268        $attributes_not_handled{"cdecl"} = 1;
269
270        my $ppfile;
271        while (<CHILD>) {
272          next if (! /warning: '([^\']+)' attribute ignored/);
273
274          # Have we already spotted this unhandled attribute?
275          next if (defined $attributes_not_handled{$1});
276          $attributes_not_handled{$1} = 1;
277        
278          # Get the name of the attribute file.
279          my $dir = "$HtmlDir/failures";
280          my $afile = "$dir/attribute_ignored_$1.txt";
281        
282          # Only create another preprocessed file if the attribute file
283          # doesn't exist yet.
284          next if (-e $afile);
285        
286          # Add this file to the list of files that contained this attribute.
287          # Generate a preprocessed file if we haven't already.
288          if (!(defined $ppfile)) {
289            $ppfile = ProcessClangFailure($Clang, $Lang, $file,
290                                          \@CmdArgsSansAnalyses,
291                                          $HtmlDir, $AttributeIgnored, $ofile);
292          }
293
294          mkpath $dir;
295          open(AFILE, ">$afile");
296          print AFILE "$ppfile\n";
297          close(AFILE);
298        }
299        close CHILD;
300      }
301    }
302  }
303  
304  unlink($ofile);
305}
306
307##----------------------------------------------------------------------------##
308#  Lookup tables.
309##----------------------------------------------------------------------------##
310
311my %CompileOptionMap = (
312  '-nostdinc' => 0,
313  '-fblocks' => 0,
314  '-fno-builtin' => 0,
315  '-fobjc-gc-only' => 0,
316  '-fobjc-gc' => 0,
317  '-ffreestanding' => 0,
318  '-include' => 1,
319  '-idirafter' => 1,
320  '-imacros' => 1,
321  '-iprefix' => 1,
322  '-iquote' => 1,
323  '-isystem' => 1,
324  '-iwithprefix' => 1,
325  '-iwithprefixbefore' => 1
326);
327
328my %LinkerOptionMap = (
329  '-framework' => 1
330);
331
332my %CompilerLinkerOptionMap = (
333  '-isysroot' => 1,
334  '-arch' => 1,
335  '-m32' => 0,
336  '-m64' => 0,
337  '-v' => 0,
338  '-fpascal-strings' => 0,
339  '-mmacosx-version-min' => 0, # This is really a 1 argument, but always has '='
340  '-miphoneos-version-min' => 0 # This is really a 1 argument, but always has '='
341);
342
343my %IgnoredOptionMap = (
344  '-MT' => 1,  # Ignore these preprocessor options.
345  '-MF' => 1,
346
347  '-fsyntax-only' => 0,
348  '-save-temps' => 0,
349  '-install_name' => 1,
350  '-exported_symbols_list' => 1,
351  '-current_version' => 1,
352  '-compatibility_version' => 1,
353  '-init' => 1,
354  '-e' => 1,
355  '-seg1addr' => 1,
356  '-bundle_loader' => 1,
357  '-multiply_defined' => 1,
358  '-sectorder' => 3,
359  '--param' => 1,
360  '-u' => 1
361);
362
363my %LangMap = (
364  'c'   => 'c',
365  'cp'  => 'c++',
366  'cpp' => 'c++',
367  'cc'  => 'c++',
368  'ii'  => 'c++',
369  'i'   => 'c-cpp-output',
370  'm'   => 'objective-c',
371  'mi'  => 'objective-c-cpp-output',
372  'mm'  => 'objective-c++'
373);
374
375my %UniqueOptions = (
376  '-isysroot' => 0  
377);
378
379##----------------------------------------------------------------------------##
380# Languages accepted.
381##----------------------------------------------------------------------------##
382
383my %LangsAccepted = (
384  "objective-c" => 1,
385  "c" => 1,
386  "c++" => 1,
387  "objective-c++" => 1
388);
389
390##----------------------------------------------------------------------------##
391#  Main Logic.
392##----------------------------------------------------------------------------##
393
394my $Action = 'link';
395my @CompileOpts;
396my @LinkOpts;
397my @Files;
398my $Lang;
399my $Output;
400my %Uniqued;
401
402# Forward arguments to gcc.
403my $Status = system($Compiler,@ARGV);
404if  (defined $ENV{'CCC_ANALYZER_LOG'}) {
405  print "$Compiler @ARGV\n";
406}
407if ($Status) { exit($Status >> 8); }
408
409# Get the analysis options.
410my $Analyses = $ENV{'CCC_ANALYZER_ANALYSIS'};
411
412# Get the store model.
413my $StoreModel = $ENV{'CCC_ANALYZER_STORE_MODEL'};
414
415# Get the constraints engine.
416my $ConstraintsModel = $ENV{'CCC_ANALYZER_CONSTRAINTS_MODEL'};
417
418# Get the output format.
419my $OutputFormat = $ENV{'CCC_ANALYZER_OUTPUT_FORMAT'};
420if (!defined $OutputFormat) { $OutputFormat = "html"; }
421
422# Determine the level of verbosity.
423my $Verbose = 0;
424if (defined $ENV{CCC_ANALYZER_VERBOSE}) { $Verbose = 1; }
425if (defined $ENV{CCC_ANALYZER_LOG}) { $Verbose = 2; }
426
427# Get the HTML output directory.
428my $HtmlDir = $ENV{'CCC_ANALYZER_HTML'};
429
430my %DisabledArchs = ('ppc' => 1, 'ppc64' => 1);
431my %ArchsSeen;
432my $HadArch = 0;
433
434# Process the arguments.
435foreach (my $i = 0; $i < scalar(@ARGV); ++$i) {
436  my $Arg = $ARGV[$i];  
437  my ($ArgKey) = split /=/,$Arg,2;
438
439  # Modes ccc-analyzer supports
440  if ($Arg =~ /^-(E|MM?)$/) { $Action = 'preprocess'; }
441  elsif ($Arg eq '-c') { $Action = 'compile'; }
442  elsif ($Arg =~ /^-print-prog-name/) { exit 0; }
443
444  # Specially handle duplicate cases of -arch
445  if ($Arg eq "-arch") {
446    my $arch = $ARGV[$i+1];
447    # We don't want to process 'ppc' because of Clang's lack of support
448    # for Altivec (also some #defines won't likely be defined correctly, etc.)
449    if (!(defined $DisabledArchs{$arch})) { $ArchsSeen{$arch} = 1; }
450    $HadArch = 1;
451    ++$i;
452    next;
453  }
454
455  # Options with possible arguments that should pass through to compiler.
456  if (defined $CompileOptionMap{$ArgKey}) {
457    my $Cnt = $CompileOptionMap{$ArgKey};
458    push @CompileOpts,$Arg;
459    while ($Cnt > 0) { ++$i; --$Cnt; push @CompileOpts, $ARGV[$i]; }
460    next;
461  }
462
463  # Options with possible arguments that should pass through to linker.
464  if (defined $LinkerOptionMap{$ArgKey}) {
465    my $Cnt = $LinkerOptionMap{$ArgKey};
466    push @LinkOpts,$Arg;
467    while ($Cnt > 0) { ++$i; --$Cnt; push @LinkOpts, $ARGV[$i]; }
468    next;
469  }
470
471  # Options with possible arguments that should pass through to both compiler
472  # and the linker.
473  if (defined $CompilerLinkerOptionMap{$ArgKey}) {
474    my $Cnt = $CompilerLinkerOptionMap{$ArgKey};
475    
476    # Check if this is an option that should have a unique value, and if so
477    # determine if the value was checked before.
478    if ($UniqueOptions{$Arg}) {
479      if (defined $Uniqued{$Arg}) {
480        $i += $Cnt;
481        next;
482      }
483      $Uniqued{$Arg} = 1;
484    }
485    
486    push @CompileOpts,$Arg;    
487    push @LinkOpts,$Arg;
488
489    while ($Cnt > 0) {
490      ++$i; --$Cnt;
491      push @CompileOpts, $ARGV[$i];
492      push @LinkOpts, $ARGV[$i];
493    }
494    next;
495  }
496  
497  # Ignored options.
498  if (defined $IgnoredOptionMap{$ArgKey}) {
499    my $Cnt = $IgnoredOptionMap{$ArgKey};
500    while ($Cnt > 0) {
501      ++$i; --$Cnt;
502    }
503    next;
504  }
505  
506  # Compile mode flags.
507  if ($Arg =~ /^-[D,I,U](.*)$/) {
508    my $Tmp = $Arg;    
509    if ($1 eq '') {
510      # FIXME: Check if we are going off the end.
511      ++$i;
512      $Tmp = $Arg . $ARGV[$i];
513    }
514    push @CompileOpts,$Tmp;
515    next;
516  }
517  
518  # Language.
519  if ($Arg eq '-x') {
520    $Lang = $ARGV[$i+1];
521    ++$i; next;
522  }
523
524  # Output file.
525  if ($Arg eq '-o') {
526    ++$i;
527    $Output = $ARGV[$i];
528    next;
529  }
530  
531  # Get the link mode.
532  if ($Arg =~ /^-[l,L,O]/) {
533    if ($Arg eq '-O') { push @LinkOpts,'-O1'; }
534    elsif ($Arg eq '-Os') { push @LinkOpts,'-O2'; }
535    else { push @LinkOpts,$Arg; }
536    next;
537  }
538  
539  if ($Arg =~ /^-std=/) {
540    push @CompileOpts,$Arg;
541    next;
542  }
543  
544#  if ($Arg =~ /^-f/) {
545#    # FIXME: Not sure if the remaining -fxxxx options have no arguments.
546#    push @CompileOpts,$Arg;
547#    push @LinkOpts,$Arg;  # FIXME: Not sure if these are link opts.
548#  }
549  
550  # Get the compiler/link mode.
551  if ($Arg =~ /^-F(.+)$/) {
552    my $Tmp = $Arg;
553    if ($1 eq '') {
554      # FIXME: Check if we are going off the end.
555      ++$i;
556      $Tmp = $Arg . $ARGV[$i];
557    }
558    push @CompileOpts,$Tmp;
559    push @LinkOpts,$Tmp;
560    next;
561  }
562
563  # Input files.
564  if ($Arg eq '-filelist') {
565    # FIXME: Make sure we aren't walking off the end.
566    open(IN, $ARGV[$i+1]);
567    while (<IN>) { s/\015?\012//; push @Files,$_; }
568    close(IN);
569    ++$i;
570    next;
571  }
572  
573  # Handle -Wno-.  We don't care about extra warnings, but
574  # we should suppress ones that we don't want to see.
575  if ($Arg =~ /^-Wno-/) {
576    push @CompileOpts, $Arg;
577    next;
578  }
579
580  if (!($Arg =~ /^-/)) {
581    push @Files, $Arg;
582    next;
583  }
584}
585
586if ($Action eq 'compile' or $Action eq 'link') {
587  my @Archs = keys %ArchsSeen;
588  # Skip the file if we don't support the architectures specified.
589  exit 0 if ($HadArch && scalar(@Archs) == 0);
590  
591  foreach my $file (@Files) {
592    # Determine the language for the file.
593    my $FileLang = $Lang;
594
595    if (!defined($FileLang)) {
596      # Infer the language from the extension.
597      if ($file =~ /[.]([^.]+)$/) {
598        $FileLang = $LangMap{$1};
599      }
600    }
601    
602    # FileLang still not defined?  Skip the file.
603    next if (!defined $FileLang);
604
605    # Language not accepted?
606    next if (!defined $LangsAccepted{$FileLang});
607
608    my @CmdArgs;
609    my @AnalyzeArgs;    
610    
611    if ($FileLang ne 'unknown') {
612      push @CmdArgs, '-x', $FileLang;
613    }
614
615    if (defined $StoreModel) {
616      push @AnalyzeArgs, "-analyzer-store=$StoreModel";
617    }
618
619    if (defined $ConstraintsModel) {
620      push @AnalyzeArgs, "-analyzer-constraints=$ConstraintsModel";
621    }
622    
623    if (defined $Analyses) {
624      push @AnalyzeArgs, split '\s+', $Analyses;
625    }
626
627    if (defined $OutputFormat) {
628      push @AnalyzeArgs, "-analyzer-output=" . $OutputFormat;
629      if ($OutputFormat =~ /plist/) {
630        # Change "Output" to be a file.
631        my ($h, $f) = tempfile("report-XXXXXX", SUFFIX => ".plist",
632                               DIR => $HtmlDir);
633        $ResultFile = $f;
634        $CleanupFile = $f;
635      }
636    }
637
638    push @CmdArgs, @CompileOpts;
639    push @CmdArgs, $file;
640
641    if (scalar @Archs) {
642      foreach my $arch (@Archs) {
643        my @NewArgs;
644        push @NewArgs, '-arch', $arch;
645        push @NewArgs, @CmdArgs;
646        Analyze($Clang, \@NewArgs, \@AnalyzeArgs, $FileLang, $Output,
647                $Verbose, $HtmlDir, $file);
648      }
649    }
650    else {
651      Analyze($Clang, \@CmdArgs, \@AnalyzeArgs, $FileLang, $Output,
652              $Verbose, $HtmlDir, $file);
653    }
654  }
655}
656
657exit($Status >> 8);
658
659