Improvements to scan-build.

[ayartsev]

Summary

Refactoring:
+ rename 'Options' to 'EnvVars' to better reflect the variables contents.
+ keep all scan-build arguments in the hash rather then in scattered variables.

All arguments were tested with the debugger. Please review!

[ayartsev]

Ping!

[ayartsev]

+ refactoring: moved processing of command-line arguments to a subroutine.

Please review!

[sylvestre.ledru]

Anna, if you want, as I am a big user of scan-build, I can do the testing of this for you.

[zaks.anna]

Anton,
Is all of this just a refactoring? I've noticed a couple of places where new functionality is being added. If that is the case, could you split that into a separate patch, explaining why that is needed.

Sylvestre,

Thank you for the offer! It would be really great if you could help us with testing this. Which platforms are you using this on?

Anton has another patch for scan-build in review. See cfe-commits "Prevent ccc/c++-analyzer from hanging on Windows." It might be best if you test all of them together. (Maybe Anton could send you the cumulative patch to save you time.)

[sylvestre.ledru]

Anna, I am testing on Debian.

I am going to wait for the patch to be split then!

[ayartsev]

Anna, just a refactoring, except line 1254 where missing "-Xclang" added before "-load". I'll make a separate patch for this.

[ayartsev]

Anna, sorry, mistaken, all of this is just a refactoring, including the line 1254.

[zaks.anna]

Ok. Sounds good.

Sylvestre,
Could you test this patch and the one labeled "Prevent ccc/c++-analyzer from hanging on Windows."?

Anton,
Does Sylvestre need an updated diff for the other patch?

[ayartsev]

Anna, Sylvestre,
"Prevent ccc/c++-analyzer from hanging on Windows." is up to date:

fork_open_hang_v2.patch4 KBDownload

Note, this patch is not included in the refactoring patch.

[sylvestre.ledru]

The second patch does not apply on top of the first.
Hunk #1 succeeded at 1258 (offset 26 lines).
Hunk #2 FAILED at 1242.
Hunk #3 succeeded at 1301 (offset 31 lines).
Hunk #4 succeeded at 1338 (offset 31 lines).

[sylvestre.ledru]

could you please use phabricator for the second patch and add a dependency on this one? Thanks

[sylvestre.ledru]

and, last but not least, the CR are broken. I don't know what you use but it seems that patch detects it as binary.

[ayartsev]

In D6551#150425, @sylvestre.ledru wrote:

The second patch does not apply on top of the first.

Yes, these patches are not cumulative. After one of the patches gets in the other must be modified.

http://reviews.llvm.org/D8774

In D6551#150426, @sylvestre.ledru wrote:

could you please use phabricator for the second patch and add a dependency on this one? Thanks

Done! Added the second patch as http://reviews.llvm.org/D8774

In D6551#150427, @sylvestre.ledru wrote:

and, last but not least, the CR are broken. I don't know what you use but it seems that patch detects it as binary.

I'll address this a bit later.

[ayartsev]

Fixed CRs.

[ayartsev]

In D6551#150427, @sylvestre.ledru wrote:

and, last but not least, the CR are broken. I don't know what you use but it seems that patch detects it as binary.

Weird.. Use 'svn diff --diff-cmd=diff -x -U999999' as usual, no specific properties are set on 'scan-build', 'svn proplist -v scan-build' gives:
Properties on 'scan-build':

svn:executable
  *
svn:keywords
  Id

Fixed CRs manually, updated the patch.

In D6551#150425, @sylvestre.ledru wrote:

The second patch does not apply on top of the first.

Could you, please, first test http://reviews.llvm.org/D8774 in order to merge it with the refactoring patch?

[ayartsev]

Gentle ping.

[ayartsev]

Ping!
Tested the patch more carefully - tested combinations of different options. Also launched scan-build over real codebases - LLVM and OGRE. No regressions found.

[sylvestre.ledru]

This is breaking the build of Firefox with scan-build with:

sh: 1: Syntax error: "(" unexpected
could not find clang line

Full log:
http://relman-ci.mozilla.org/job/firefox-scan-build/77/consoleFull

By the way, this error message should be improved.

[ayartsev]

Updated the patch.

[ayartsev]

Ping!

[sylvestre.ledru]

I rebuilt Firefox code with this change under Debian and it works great.
So, LGTM (but I am not the owner of this code)

[sylvestre.ledru]

(if you commit it, please update the description, "Improvements to scan-build" is too general

[honggyu.kim]

Hi all,

I have also tested this patch by analyzing ARM version of Linux kernel with my patch D10356.
I successfully got the result after resolving a simple indentation conflict by modifying my patch.
If this patch is committed first then I will update D10356 based on it.

Honggyu

[honggyu.kim]

Hi Anton,

Since D10356 is committed first, your patch(D6551) has to be modified based on it.
So I just did some modification to resolve a conflict.

I was trying to upload the patch in phabricator, but I don't have a permission to update your patch.
I just attached the modified version so that you can easily upload it.

Thanks,
Honggyu

• D6551_v5.patch58 KBDownload

[ayartsev]

Hi Honggyu,
thanks for updating the patch!

The new patch contains changes introduced by r244400 (D10356) and r244673 plus some simplifications.
Ok to commit?

[ayartsev]

Updated the patch with r245621.
OK to commit?

[sylvestre.ledru]

Anton, I think you should just commit it. We can always iterate on this later if it breaks anything.
The patch is big and rebasing is time consuming.

[dcoughlin]

I ran our build-bot scripts with this and it looks good to me, although I've noted two places with trailing whitespace. Thanks for your patience!

tools/scan-build/scan-build

1403

Trailing whitespace here.

1774

Trailing whitespace here.

[zaks.anna]

Please, make sure to include a very specific commit title/message.

[ayartsev]

Removed trailing whitespaces and committed as r246710.
Thanks for reviews and assistance!

[sylvestre.ledru]

To close this review.

tools/scan-build/scan-build

 use File::Basename;
 use File::Find;
 use File::Copy qw(copy);
 use File::Path qw( rmtree mkpath );
 use Term::ANSIColor;
 use Term::ANSIColor qw(:constants);
 use Cwd qw/ getcwd abs_path /;
 use Sys::Hostname;
+use Hash::Util qw(lock_keys);
 
-my $Verbose = 0;       # Verbose output from this script.
 my $Prog = "scan-build";
 my $BuildName;
 my $BuildDate;
 
 my $TERM = $ENV{'TERM'};
 my $UseColor = (defined $TERM and $TERM =~ 'xterm-.*color' and -t STDOUT
                 and defined $ENV{'SCAN_BUILD_COLOR'});
 
 # Portability: getpwuid is not implemented for Win32 (see Perl language
 # reference, perlport), use getlogin instead.
 my $UserName = HtmlEscape(getlogin() || getpwuid($<) || 'unknown');
 my $HostName = HtmlEscape(hostname() || 'unknown');
 my $CurrentDir = HtmlEscape(getcwd());
-my $CurrentDirSuffix = basename($CurrentDir);
 
-my @PluginsToLoad;
 my $CmdArgs;
 
-my $HtmlTitle;
-
 my $Date = localtime();
 
+# Command-line/config arguments.
+my %Options = (
+  Verbose => 0,              # Verbose output from this script.
+  AnalyzeHeaders => 0,
+  OutputDir => undef,        # Parent directory to store HTML files.
+  HtmlTitle => basename($CurrentDir)." - scan-build results",
+  IgnoreErrors => 0,         # Ignore build errors.
+  ViewResults => 0,          # View results when the build terminates.
+  ExitStatusFoundBugs => 0,  # Exit status reflects whether bugs were found
+  KeepEmpty => 0,            # Don't remove output directory even with 0 results.
+  EnableCheckers => [],
+  DisableCheckers => [],
+  UseCC => undef,            # C compiler to use for compilation.
+  UseCXX => undef,           # C++ compiler to use for compilation.
+  AnalyzerTarget => undef,
+  StoreModel => undef,
+  ConstraintsModel => undef,
+  InternalStats => undef,
+  OutputFormat => "html",
+  ConfigOptions => [],       # Options to pass through to the analyzer's -analyzer-config flag.
+  ReportFailures => undef,
+  AnalyzerStats => 0,
+  MaxLoop => 0,
+  PluginsToLoad => [],
+  AnalyzerDiscoveryMethod => undef,
+  OverrideCompiler => 0      # The flag corresponding to the --override-compiler command line option.
+);
+lock_keys(%Options);
+
 ##----------------------------------------------------------------------------##
 # Diagnostics
 ##----------------------------------------------------------------------------##
 
 sub Diag {
   if ($UseColor) {
     print BOLD, MAGENTA "$Prog: @_";
     print RESET;
sub SetHtmlEnv {
   die "No build command." if (scalar(@$Args) == 0);
 
   my $Cmd = $$Args[0];
 
   if ($Cmd =~ /configure/ || $Cmd =~ /autogen/) {
     return;
   }
 
-  if ($Verbose) {
+  if ($Options{Verbose}) {
     Diag("Emitting reports for this run to '$Dir'.\n");
   }
 
   $ENV{'CCC_ANALYZER_HTML'} = $Dir;
 }
 
 ##----------------------------------------------------------------------------##
 # ComputeDigest - Compute a digest of the specified file.
sub Postprocess {
   my $FName = "$Dir/index.html";
   open(OUT, ">", $FName) or DieDiag("Cannot create file '$FName'\n");
 
   # Print out the header.
 
 print OUT <<ENDTEXT;
 <html>
 <head>
-<title>${HtmlTitle}</title>
+<title>${Options{HtmlTitle}}</title>
 <link type="text/css" rel="stylesheet" href="scanview.css"/>
 <script src="sorttable.js"></script>
 <script language='javascript' type="text/javascript">
 function SetDisplay(RowClass, DisplayVal)
 {
   var Rows = document.getElementsByTagName("tr");
   for ( var i = 0 ; i < Rows.length; ++i ) {
     if (Rows[i].className == RowClass) {
else {
     NumUnchecked++;
     returnObjById("AllBugsCheck").checked = false;
   }
 }
 </script>
 <!-- SUMMARYENDHEAD -->
 </head>
 <body>
-<h1>${HtmlTitle}</h1>
+<h1>${Options{HtmlTitle}}</h1>
 
 <table>
 <tr><th>User:</th><td>${UserName}\@${HostName}</td></tr>
 <tr><th>Working Directory:</th><td>${CurrentDir}</td></tr>
 <tr><th>Command Line:</th><td>${CmdArgs}</td></tr>
 <tr><th>Clang Version:</th><td>${ClangVersion}</td></tr>
 <tr><th>Date:</th><td>${Date}</td></tr>
 ENDTEXT
sub AddIfNotPresent {
   }
 
   if ($found == 0) {
     push @$Args, $Arg;
   }
 }
 
 sub SetEnv {
-  my $Options = shift @_;
-  foreach my $opt ('CC', 'CXX', 'CLANG', 'CLANG_CXX',
-                    'CCC_ANALYZER_ANALYSIS', 'CCC_ANALYZER_PLUGINS',
-                    'CCC_ANALYZER_CONFIG') {
-    die "$opt is undefined\n" if (!defined $opt);
-    $ENV{$opt} = $Options->{$opt};
+  my $EnvVars = shift @_;
+  foreach my $var ('CC', 'CXX', 'CLANG', 'CLANG_CXX',
+    die "$var is undefined\n" if (!defined $var);
+    $ENV{$var} = $EnvVars->{$var};
   }
-  foreach my $opt ('CCC_ANALYZER_STORE_MODEL',
-                    'CCC_ANALYZER_CONSTRAINTS_MODEL',
-                    'CCC_ANALYZER_INTERNAL_STATS',
-                    'CCC_ANALYZER_OUTPUT_FORMAT') {
-    my $x = $Options->{$opt};
-    if (defined $x) { $ENV{$opt} = $x }
+  foreach my $var ('CCC_ANALYZER_STORE_MODEL',
+                   'CCC_ANALYZER_OUTPUT_FORMAT',
+                   'CCC_CC',
+                   'CCC_CXX',
+                   'CCC_REPORT_FAILURES',
+                   'CLANG_ANALYZER_TARGET') {
+    my $x = $EnvVars->{$var};
+    if (defined $x) { $ENV{$var} = $x }
   }
-  my $Verbose = $Options->{'VERBOSE'};
+  my $Verbose = $EnvVars->{'VERBOSE'};
   if ($Verbose >= 2) {
     $ENV{'CCC_ANALYZER_VERBOSE'} = 1;
   }
   if ($Verbose >= 3) {
     $ENV{'CCC_ANALYZER_LOG'} = 1;
   }
 }
 
-# The flag corresponding to the --override-compiler command line option.
-my $OverrideCompiler = 0;
-
 sub RunXcodebuild {
   my $Args = shift;
   my $IgnoreErrors = shift;
   my $CCAnalyzer = shift;
   my $CXXAnalyzer = shift;
-  my $Options = shift;
+  my $EnvVars = shift;
 
   if ($IgnoreErrors) {
     AddIfNotPresent($Args,"-PBXBuildsContinueAfterErrors=YES");
   }
 
   # Detect the version of Xcode.  If Xcode 4.6 or higher, use new
   # in situ support for analyzer interposition without needed to override
   # the compiler.
if (/^Xcode (.+)$/) {
         }
       }
     }
   }
   close(DETECT_XCODE);
 
   # If --override-compiler is explicitely requested, resort to the old
   # behavior regardless of Xcode version.
-  if ($OverrideCompiler) {
+  if ($Options{OverrideCompiler}) {
     $oldBehavior = 1;
   }
 
   if ($oldBehavior == 0) {
-    my $OutputDir = $Options->{"OUTPUT_DIR"};
-    my $CLANG = $Options->{"CLANG"};
-    my $OtherFlags = $Options->{"CCC_ANALYZER_ANALYSIS"};
+    my $OutputDir = $EnvVars->{"OUTPUT_DIR"};
+    my $CLANG = $EnvVars->{"CLANG"};
+    my $OtherFlags = $EnvVars->{"CCC_ANALYZER_ANALYSIS"};
     push @$Args,
         "RUN_CLANG_STATIC_ANALYZER=YES",
         "CLANG_ANALYZER_OUTPUT=plist-html",
         "CLANG_ANALYZER_EXEC=$CLANG",
         "CLANG_ANALYZER_OUTPUT_DIR=$OutputDir",
         "CLANG_ANALYZER_OTHER_FLAGS=$OtherFlags";
 
     return (system(@$Args) >> 8);
   }
 
   # Default to old behavior where we insert a bogus compiler.
-  SetEnv($Options);
+  SetEnv($EnvVars);
 
   # Check if using iPhone SDK 3.0 (simulator).  If so the compiler being
   # used should be gcc-4.2.
   if (!defined $ENV{"CCC_CC"}) {
     for (my $i = 0 ; $i < scalar(@$Args); ++$i) {
       if ($Args->[$i] eq "-sdk" && $i + 1 < scalar(@$Args)) {
         if (@$Args[$i+1] =~ /^iphonesimulator3/) {
           $ENV{"CCC_CC"} = "gcc-4.2";

 }
 
 sub RunBuildCommand {
   my $Args = shift;
   my $IgnoreErrors = shift;
   my $Cmd = $Args->[0];
   my $CCAnalyzer = shift;
   my $CXXAnalyzer = shift;
-  my $Options = shift;
+  my $EnvVars = shift;
 
   if ($Cmd =~ /\bxcodebuild$/) {
-    return RunXcodebuild($Args, $IgnoreErrors, $CCAnalyzer, $CXXAnalyzer, $Options);
+    return RunXcodebuild($Args, $IgnoreErrors, $CCAnalyzer, $CXXAnalyzer, $EnvVars);
   }
 
   # Setup the environment.
-  SetEnv($Options);
+  SetEnv($EnvVars);
 
   if ($Cmd =~ /(.*\/?gcc[^\/]*$)/ or
       $Cmd =~ /(.*\/?cc[^\/]*$)/ or
       $Cmd =~ /(.*\/?llvm-gcc[^\/]*$)/ or
       $Cmd =~ /(.*\/?clang$)/ or
       $Cmd =~ /(.*\/?ccc-analyzer[^\/]*$)/) {
 
     if (!($Cmd =~ /ccc-analyzer/) and !defined $ENV{"CCC_CC"}) {

  -load-plugin [plugin library]
 ENDTEXT
 
   # Query clang for list of checkers that are enabled.
 
   # create a list to load the plugins via the 'Xclang' command line
   # argument
   my @PluginLoadCommandline_xclang;
-  foreach my $param ( @PluginsToLoad ) {
+  foreach my $param ( @{$Options{PluginsToLoad}} ) {
+    push ( @PluginLoadCommandline_xclang, "-Xclang" );
+    push ( @PluginLoadCommandline_xclang, "-load" );
     push ( @PluginLoadCommandline_xclang, "-Xclang" );
     push ( @PluginLoadCommandline_xclang, $param );
   }
+
   my %EnabledCheckers;
   foreach my $lang ("c", "objective-c", "objective-c++", "c++") {
     my $ExecLine = join(' ', qq/"$Clang"/, @PluginLoadCommandline_xclang, "--analyze", "-x", $lang, "-", "-###", "2>&1", "|");
     open(PS, $ExecLine);
     while (<PS>) {
       foreach my $val (split /\s+/) {
         $val =~ s/\"//g;
         if ($val =~ /-analyzer-checker\=([^\s]+)/) {
           $EnabledCheckers{$1} = 1;
         }
       }
     }
   }
 
   # Query clang for complete list of checkers.
+  my @PluginLoadCommandline;
+  foreach my $param ( @{$Options{PluginsToLoad}} ) {
+    push ( @PluginLoadCommandline, "-load" );
+    push ( @PluginLoadCommandline, $param );
+  }
   if (defined $Clang && -x $Clang) {
-    my $ExecLine = join(' ', qq/"$Clang"/, "-cc1", @PluginsToLoad, "-analyzer-checker-help", "2>&1", "|");
+    my $ExecLine = join(' ', qq/"$Clang"/, "-cc1", @PluginLoadCommandline, "-analyzer-checker-help", "2>&1", "|");
     open(PS, $ExecLine);
     my $foundCheckers = 0;
     while (<PS>) {
       if (/CHECKERS:/) {
         $foundCheckers = 1;
         last;
       }
     }
sub ShellEscape {
   if ($arg =~ /["\s]/) { return "'" . $arg . "'"; }
   return $arg;
 }
 
 ##----------------------------------------------------------------------------##
 # Process command-line arguments.
 ##----------------------------------------------------------------------------##
 
-my $AnalyzeHeaders = 0;
-my $HtmlDir;           # Parent directory to store HTML files.
-my $IgnoreErrors = 0;  # Ignore build errors.
-my $ViewResults  = 0;  # View results when the build terminates.
-my $ExitStatusFoundBugs = 0; # Exit status reflects whether bugs were found
-my $KeepEmpty    = 0;  # Don't remove output directory even with 0 results.
-my @AnalysesToRun;
-my $StoreModel;
-my $ConstraintsModel;
-my $InternalStats;
-my @ConfigOptions;
-my $OutputFormat = "html";
-my $AnalyzerStats = 0;
-my $MaxLoop = 0;
 my $RequestDisplayHelp = 0;
 my $ForceDisplayHelp = 0;
-my $AnalyzerDiscoveryMethod;
 
-if (!@ARGV) {
-  $ForceDisplayHelp = 1
-}
+sub ProcessArgs {
+  my $Args = shift;
   
-while (@ARGV) {
+  while (@$Args) {
 
     # Scan for options we recognize.
 
-  my $arg = $ARGV[0];
+    my $arg = $Args->[0];
 
     if ($arg eq "-h" or $arg eq "--help") {
       $RequestDisplayHelp = 1;
-    shift @ARGV;
+      shift @$Args;
       next;
     }
 
     if ($arg eq '-analyze-headers') {
-    shift @ARGV;
-    $AnalyzeHeaders = 1;
+      shift @$Args;
+      $Options{AnalyzeHeaders} = 1;
       next;
     }
 
     if ($arg eq "-o") {
-    shift @ARGV;
+      shift @$Args;
 
-    if (!@ARGV) {
+      if (!@$Args) {
         DieDiag("'-o' option requires a target directory name.\n");
       }
 
       # Construct an absolute path.  Uses the current working directory
       # as a base if the original path was not absolute.
-    $HtmlDir = abs_path(shift @ARGV);
+      $Options{OutputDir} = abs_path(shift @$Args);
 
       next;
     }
 
     if ($arg =~ /^--html-title(=(.+))?$/) {
-    shift @ARGV;
+      shift @$Args;
 
       if (!defined $2 || $2 eq '') {
-      if (!@ARGV) {
+        if (!@$Args) {
           DieDiag("'--html-title' option requires a string.\n");
         }
 
-      $HtmlTitle = shift @ARGV;
+        $Options{HtmlTitle} = shift @$Args;
       } else {
-      $HtmlTitle = $2;
+        $Options{HtmlTitle} = $2;
       }
 
       next;
     }
 
     if ($arg eq "-k" or $arg eq "--keep-going") {
-    shift @ARGV;
-    $IgnoreErrors = 1;
+      shift @$Args;
+      $Options{IgnoreErrors} = 1;
       next;
     }
 
     if ($arg =~ /^--use-cc(=(.+))?$/) {
-    shift @ARGV;
+      shift @$Args;
       my $cc;
 
       if (!defined $2 || $2 eq "") {
-      if (!@ARGV) {
+        if (!@$Args) {
           DieDiag("'--use-cc' option requires a compiler executable name.\n");
         }
-      $cc = shift @ARGV;
+        $cc = shift @$Args;
       }
       else {
         $cc = $2;
       }
 
-    $ENV{"CCC_CC"} = $cc;
+      $Options{UseCC} = $cc;
       next;
     }
 
     if ($arg =~ /^--use-c\+\+(=(.+))?$/) {
-    shift @ARGV;
+      shift @$Args;
       my $cxx;
 
       if (!defined $2 || $2 eq "") {
-      if (!@ARGV) {
+        if (!@$Args) {
           DieDiag("'--use-c++' option requires a compiler executable name.\n");
         }
-      $cxx = shift @ARGV;
+        $cxx = shift @$Args;
       }
       else {
         $cxx = $2;
       }
 
-    $ENV{"CCC_CXX"} = $cxx;
+      $Options{UseCXX} = $cxx;
       next;
     }
 
     if ($arg =~ /^--analyzer-target(=(.+))?$/) {
       shift @ARGV;
       my $AnalyzerTarget;
 
       if (!defined $2 || $2 eq "") {
         if (!@ARGV) {
           DieDiag("'--analyzer-target' option requires a target triple name.\n");
         }
         $AnalyzerTarget = shift @ARGV;
       }
       else {
         $AnalyzerTarget = $2;
       }
 
-    $ENV{"CLANG_ANALYZER_TARGET"} = $AnalyzerTarget;
+      $Options{AnalyzerTarget} = $AnalyzerTarget;
       next;
     }
 
     if ($arg eq "-v") {
-    shift @ARGV;
-    $Verbose++;
+      shift @$Args;
+      $Options{Verbose}++;
       next;
     }
 
     if ($arg eq "-V" or $arg eq "--view") {
-    shift @ARGV;
-    $ViewResults = 1;
+      shift @$Args;
+      $Options{ViewResults} = 1;
       next;
     }
 
     if ($arg eq "--status-bugs") {
-    shift @ARGV;
-    $ExitStatusFoundBugs = 1;
+      shift @$Args;
+      $Options{ExitStatusFoundBugs} = 1;
       next;
     }
 
     if ($arg eq "-store") {
-    shift @ARGV;
-    $StoreModel = shift @ARGV;
+      shift @$Args;
+      $Options{StoreModel} = shift @$Args;
       next;
     }
 
     if ($arg eq "-constraints") {
-    shift @ARGV;
-    $ConstraintsModel = shift @ARGV;
+      shift @$Args;
+      $Options{ConstraintsModel} = shift @$Args;
       next;
     }
 
     if ($arg eq "-internal-stats") {
-    shift @ARGV;
-    $InternalStats = 1;
+      shift @$Args;
+      $Options{InternalStats} = 1;
       next;
     }
 
     if ($arg eq "-plist") {
-    shift @ARGV;
-    $OutputFormat = "plist";
+      shift @$Args;
+      $Options{OutputFormat} = "plist";
       next;
     }
+
     if ($arg eq "-plist-html") {
-    shift @ARGV;
-    $OutputFormat = "plist-html";
+      shift @$Args;
+      $Options{OutputFormat} = "plist-html";
       next;
     }
 
     if ($arg eq "-analyzer-config") {
-    shift @ARGV;
-    push @ConfigOptions, "-analyzer-config", shift @ARGV;
+      shift @$Args;
+      push @{$Options{ConfigOptions}}, shift @$Args;
       next;
     }
 
     if ($arg eq "-no-failure-reports") {
-    shift @ARGV;
-    $ENV{"CCC_REPORT_FAILURES"} = 0;
+      shift @$Args;
+      $Options{ReportFailures} = 0;
       next;
     }
+
     if ($arg eq "-stats") {
-    shift @ARGV;
-    $AnalyzerStats = 1;
+      shift @$Args;
+      $Options{AnalyzerStats} = 1;
       next;
     }
+
     if ($arg eq "-maxloop") {
-    shift @ARGV;
-    $MaxLoop = shift @ARGV;
+      shift @$Args;
+      $Options{MaxLoop} = shift @$Args;
       next;
     }
+
     if ($arg eq "-enable-checker") {
-    shift @ARGV;
-    push @AnalysesToRun, "-analyzer-checker", shift @ARGV;
+      shift @$Args;
+      push @{$Options{EnableCheckers}}, shift @$Args;
       next;
     }
+
     if ($arg eq "-disable-checker") {
-    shift @ARGV;
-    push @AnalysesToRun, "-analyzer-disable-checker", shift @ARGV;
+      shift @$Args;
+      push @{$Options{DisableCheckers}}, shift @$Args;
       next;
     }
+
     if ($arg eq "-load-plugin") {
-    shift @ARGV;
-    push @PluginsToLoad, "-load", shift @ARGV;
+      shift @$Args;
+      push @{$Options{PluginsToLoad}}, shift @$Args;
       next;
     }
+
     if ($arg eq "--use-analyzer") {
-     shift @ARGV;
-      $AnalyzerDiscoveryMethod = shift @ARGV;
+      shift @$Args;
+      $Options{AnalyzerDiscoveryMethod} = shift @$Args;
       next;
     }
+
     if ($arg =~ /^--use-analyzer=(.+)$/) {
-    shift @ARGV;
-    $AnalyzerDiscoveryMethod = $1;
+      shift @$Args;
+      $Options{AnalyzerDiscoveryMethod} = $1;
       next;
     }
+
     if ($arg eq "--keep-empty") {
-    shift @ARGV;
-    $KeepEmpty = 1;
+      shift @$Args;
+      $Options{KeepEmpty} = 1;
       next;
     }
 
     if ($arg eq "--override-compiler") {
-    shift @ARGV;
-    $OverrideCompiler = 1;
+      shift @$Args;
+      $Options{OverrideCompiler} = 1;
       next;
     }
 
     DieDiag("unrecognized option '$arg'\n") if ($arg =~ /^-/);
 
     last;
   }
+}
+
+if (!@ARGV) {
+  $ForceDisplayHelp = 1
+}
+
+ProcessArgs(\@ARGV);
 
 if (!@ARGV and !$RequestDisplayHelp) {
   ErrorDiag("No build command specified.\n\n");
   $ForceDisplayHelp = 1;
 }
 
 # Find 'clang'
-if (!defined $AnalyzerDiscoveryMethod) {
+if (!defined $Options{AnalyzerDiscoveryMethod}) {
   $Clang = Cwd::realpath("$RealBin/bin/clang");
   if (!defined $Clang || ! -x $Clang) {
     $Clang = Cwd::realpath("$RealBin/clang");
   }
   if (!defined $Clang || ! -x $Clang) {
     if (!$RequestDisplayHelp && !$ForceDisplayHelp) {
       DieDiag("error: Cannot find an executable 'clang' relative to scan-build." .
                  "  Consider using --use-analyzer to pick a version of 'clang' to use for static analysis.\n");
     }
   }
 }
 else {
-  if ($AnalyzerDiscoveryMethod =~ /^[Xx]code$/) {
+  if ($Options{AnalyzerDiscoveryMethod} =~ /^[Xx]code$/) {
     my $xcrun = `which xcrun`;
     chomp $xcrun;
     if ($xcrun eq "") {
         DieDiag("Cannot find 'xcrun' to find 'clang' for analysis.\n");
     }
     $Clang = `$xcrun -toolchain XcodeDefault -find clang`;
     chomp $Clang;
     if ($Clang eq "") {
       DieDiag("No 'clang' executable found by 'xcrun'\n");
     }
   }
   else {
-    $Clang = $AnalyzerDiscoveryMethod;
+    $Clang = $Options{AnalyzerDiscoveryMethod};
     if (!defined $Clang or not -x $Clang) {
-         DieDiag("Cannot find an executable clang at '$AnalyzerDiscoveryMethod'\n");
+      DieDiag("Cannot find an executable clang at '$Options{AnalyzerDiscoveryMethod}'\n");
     }
   }
 }
 
 if ($ForceDisplayHelp || $RequestDisplayHelp) {
   DisplayHelp();
   exit $ForceDisplayHelp;
 }
if ($Clang !~ /\+\+(\.exe)?$/) {
   }
 }
 
 # Make sure to use "" to handle paths with spaces.
 $ClangVersion = HtmlEscape(`"$Clang" --version`);
 
 # Determine where results go.
 $CmdArgs = HtmlEscape(join(' ', map(ShellEscape($_), @ARGV)));
-$HtmlTitle = "${CurrentDirSuffix} - scan-build results"
-  unless (defined($HtmlTitle));
 
 # Determine the output directory for the HTML reports.
-my $BaseDir = $HtmlDir;
-$HtmlDir = GetHTMLRunDir($HtmlDir);
+my $BaseDir = $Options{OutputDir};
+$Options{OutputDir} = GetHTMLRunDir($Options{OutputDir});
 
 # Determine the location of ccc-analyzer.
 my $AbsRealBin = Cwd::realpath($RealBin);
 my $Cmd = "$AbsRealBin/libexec/ccc-analyzer";
 my $CmdCXX = "$AbsRealBin/libexec/c++-analyzer";
 
 # Portability: use less strict but portable check -e (file exists) instead of
 # non-portable -x (file is executable). On some windows ports -x just checks
 # file extension to determine if a file is executable (see Perl language
 # reference, perlport)
 if (!defined $Cmd || ! -e $Cmd) {
   $Cmd = "$AbsRealBin/ccc-analyzer";
   DieDiag("'ccc-analyzer' does not exist at '$Cmd'\n") if(! -e $Cmd);
 }
 if (!defined $CmdCXX || ! -e $CmdCXX) {
   $CmdCXX = "$AbsRealBin/c++-analyzer";
   DieDiag("'c++-analyzer' does not exist at '$CmdCXX'\n") if(! -e $CmdCXX);
 }
 
 Diag("Using '$Clang' for static analysis\n");
 
-SetHtmlEnv(\@ARGV, $HtmlDir);
-if ($AnalyzeHeaders) { push @AnalysesToRun,"-analyzer-opt-analyze-headers"; }
-if ($AnalyzerStats) { push @AnalysesToRun, '-analyzer-checker=debug.Stats'; }
-if ($MaxLoop > 0) { push @AnalysesToRun, "-analyzer-max-loop $MaxLoop"; }
+SetHtmlEnv(\@ARGV, $Options{OutputDir});
+
+my @AnalysesToRun;
+foreach (@{$Options{EnableCheckers}}) { push @AnalysesToRun, "-analyzer-checker", $_; }
+foreach (@{$Options{DisableCheckers}}) { push @AnalysesToRun, "-analyzer-disable-checker", $_; }
+if ($Options{AnalyzeHeaders}) { push @AnalysesToRun, "-analyzer-opt-analyze-headers"; }
+if ($Options{AnalyzerStats}) { push @AnalysesToRun, '-analyzer-checker=debug.Stats'; }
+if ($Options{MaxLoop} > 0) { push @AnalysesToRun, "-analyzer-max-loop $Options{MaxLoop}"; }
 
 # Delay setting up other environment variables in case we can do true
 # interposition.
-my $CCC_ANALYZER_ANALYSIS = join ' ',@AnalysesToRun;
-my $CCC_ANALYZER_PLUGINS = join ' ',@PluginsToLoad;
-my $CCC_ANALYZER_CONFIG = join ' ',@ConfigOptions;
-my %Options = (
+my $CCC_ANALYZER_ANALYSIS = join ' ', @AnalysesToRun;
+my $CCC_ANALYZER_PLUGINS = join ' ', map { "-load ".$_ } @{$Options{PluginsToLoad}};
+my $CCC_ANALYZER_CONFIG = join ' ', map { "-analyzer-config ".$_ } @{$Options{ConfigOptions}};
+my %EnvVars = (
   'CC' => $Cmd,
   'CXX' => $CmdCXX,
   'CLANG' => $Clang,
   'CLANG_CXX' => $ClangCXX,
-  'VERBOSE' => $Verbose,
+  'VERBOSE' => $Options{Verbose},
   'CCC_ANALYZER_ANALYSIS' => $CCC_ANALYZER_ANALYSIS,
   'CCC_ANALYZER_PLUGINS' => $CCC_ANALYZER_PLUGINS,
   'CCC_ANALYZER_CONFIG' => $CCC_ANALYZER_CONFIG,
-  'OUTPUT_DIR' => $HtmlDir
+  'OUTPUT_DIR' => $Options{OutputDir},
+  'CCC_CC' => $Options{UseCC},
+  'CCC_CXX' => $Options{UseCXX},
+  'CCC_REPORT_FAILURES' => $Options{ReportFailures},
+  'CCC_ANALYZER_STORE_MODEL' => $Options{StoreModel},
+  'CCC_ANALYZER_CONSTRAINTS_MODEL' => $Options{ConstraintsModel},
+  'CCC_ANALYZER_INTERNAL_STATS' => $Options{InternalStats},
+  'CCC_ANALYZER_OUTPUT_FORMAT' => $Options{OutputFormat},
+  'CLANG_ANALYZER_TARGET' => $Options{AnalyzerTarget}
 );
 
-if (defined $StoreModel) {
-  $Options{'CCC_ANALYZER_STORE_MODEL'} = $StoreModel;
-}
-if (defined $ConstraintsModel) {
-  $Options{'CCC_ANALYZER_CONSTRAINTS_MODEL'} = $ConstraintsModel;
-}
-if (defined $InternalStats) {
-  $Options{'CCC_ANALYZER_INTERNAL_STATS'} = 1;
-}
-if (defined $OutputFormat) {
-  $Options{'CCC_ANALYZER_OUTPUT_FORMAT'} = $OutputFormat;
-}
-
 # Run the build.
-my $ExitStatus = RunBuildCommand(\@ARGV, $IgnoreErrors, $Cmd, $CmdCXX,
-                                \%Options);
+my $ExitStatus = RunBuildCommand(\@ARGV, $Options{IgnoreErrors}, $Cmd, $CmdCXX,
+                                \%EnvVars);
 
-if (defined $OutputFormat) {
-  if ($OutputFormat =~ /plist/) {
+if (defined $Options{OutputFormat}) {
+  if ($Options{OutputFormat} =~ /plist/) {
     Diag "Analysis run complete.\n";
-    Diag "Analysis results (plist files) deposited in '$HtmlDir'\n";
+    Diag "Analysis results (plist files) deposited in '$Options{OutputDir}'\n";
   }
-  if ($OutputFormat =~ /html/) {
+  if ($Options{OutputFormat} =~ /html/) {
     # Postprocess the HTML directory.
-    my $NumBugs = Postprocess($HtmlDir, $BaseDir, $AnalyzerStats, $KeepEmpty);
+    my $NumBugs = Postprocess($Options{OutputDir}, $BaseDir, 
+                              $Options{AnalyzerStats}, $Options{KeepEmpty});
 
-    if ($ViewResults and -r "$HtmlDir/index.html") {
+    if ($Options{ViewResults} and -r "$Options{OutputDir}/index.html") {
       Diag "Analysis run complete.\n";
-      Diag "Viewing analysis results in '$HtmlDir' using scan-view.\n";
+      Diag "Viewing analysis results in '$Options{OutputDir}' using scan-view.\n";
       my $ScanView = Cwd::realpath("$RealBin/scan-view");
       if (! -x $ScanView) { $ScanView = "scan-view"; }
-      exec $ScanView, "$HtmlDir";
+      exec $ScanView, "$Options{OutputDir}";
     }
 
-    if ($ExitStatusFoundBugs) {
+    if ($Options{ExitStatusFoundBugs}) {
       exit 1 if ($NumBugs > 0);
       exit 0;
     }
   }
 }
 
 exit $ExitStatus;