Diff 22727

tools/scan-build/scan-build

Show All 18 Lines
use File::Basename;		use File::Basename;
use File::Find;		use File::Find;
use File::Copy qw(copy);		use File::Copy qw(copy);
use File::Path qw( rmtree mkpath );		use File::Path qw( rmtree mkpath );
use Term::ANSIColor;		use Term::ANSIColor;
use Term::ANSIColor qw(:constants);		use Term::ANSIColor qw(:constants);
use Cwd qw/ getcwd abs_path /;		use Cwd qw/ getcwd abs_path /;
use Sys::Hostname;		use Sys::Hostname;
		use Hash::Util qw(lock_keys);

my $Verbose = 0; # Verbose output from this script.
my $Prog = "scan-build";		my $Prog = "scan-build";
my $BuildName;		my $BuildName;
my $BuildDate;		my $BuildDate;

my $TERM = $ENV{'TERM'};		my $TERM = $ENV{'TERM'};
my $UseColor = (defined $TERM and $TERM =~ 'xterm-.*color' and -t STDOUT		my $UseColor = (defined $TERM and $TERM =~ 'xterm-.*color' and -t STDOUT
and defined $ENV{'SCAN_BUILD_COLOR'});		and defined $ENV{'SCAN_BUILD_COLOR'});

# Portability: getpwuid is not implemented for Win32 (see Perl language		# Portability: getpwuid is not implemented for Win32 (see Perl language
# reference, perlport), use getlogin instead.		# reference, perlport), use getlogin instead.
my $UserName = HtmlEscape(getlogin() \|\| getpwuid($<) \|\| 'unknown');		my $UserName = HtmlEscape(getlogin() \|\| getpwuid($<) \|\| 'unknown');
		dcoughlinUnsubmitted Not Done Reply Inline Actions Trailing whitespace here. dcoughlin: Trailing whitespace here.
my $HostName = HtmlEscape(hostname() \|\| 'unknown');		my $HostName = HtmlEscape(hostname() \|\| 'unknown');
my $CurrentDir = HtmlEscape(getcwd());		my $CurrentDir = HtmlEscape(getcwd());
my $CurrentDirSuffix = basename($CurrentDir);

my @PluginsToLoad;
my $CmdArgs;		my $CmdArgs;

my $HtmlTitle;

my $Date = localtime();		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.
		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		# Diagnostics
##----------------------------------------------------------------------------##		##----------------------------------------------------------------------------##

sub Diag {		sub Diag {
if ($UseColor) {		if ($UseColor) {
print BOLD, MAGENTA "$Prog: @_";		print BOLD, MAGENTA "$Prog: @_";
print RESET;		print RESET;
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines	sub SetHtmlEnv {
die "No build command." if (scalar(@$Args) == 0);		die "No build command." if (scalar(@$Args) == 0);

my $Cmd = $$Args[0];		my $Cmd = $$Args[0];

if ($Cmd =~ /configure/ \|\| $Cmd =~ /autogen/) {		if ($Cmd =~ /configure/ \|\| $Cmd =~ /autogen/) {
return;		return;
}		}

if ($Verbose) {		if ($Options{Verbose}) {
Diag("Emitting reports for this run to '$Dir'.\n");		Diag("Emitting reports for this run to '$Dir'.\n");
}		}

$ENV{'CCC_ANALYZER_HTML'} = $Dir;		$ENV{'CCC_ANALYZER_HTML'} = $Dir;
}		}

##----------------------------------------------------------------------------##		##----------------------------------------------------------------------------##
# ComputeDigest - Compute a digest of the specified file.		# ComputeDigest - Compute a digest of the specified file.
▲ Show 20 Lines • Show All 334 Lines • ▼ Show 20 Lines	sub Postprocess {
my $FName = "$Dir/index.html";		my $FName = "$Dir/index.html";
open(OUT, ">", $FName) or DieDiag("Cannot create file '$FName'\n");		open(OUT, ">", $FName) or DieDiag("Cannot create file '$FName'\n");

# Print out the header.		# Print out the header.

print OUT <<ENDTEXT;		print OUT <<ENDTEXT;
<html>		<html>
<head>		<head>
<title>${HtmlTitle}</title>		<title>${Options{HtmlTitle}}</title>
<link type="text/css" rel="stylesheet" href="scanview.css"/>		<link type="text/css" rel="stylesheet" href="scanview.css"/>
<script src="sorttable.js"></script>		<script src="sorttable.js"></script>
<script language='javascript' type="text/javascript">		<script language='javascript' type="text/javascript">
function SetDisplay(RowClass, DisplayVal)		function SetDisplay(RowClass, DisplayVal)
{		{
var Rows = document.getElementsByTagName("tr");		var Rows = document.getElementsByTagName("tr");
for ( var i = 0 ; i < Rows.length; ++i ) {		for ( var i = 0 ; i < Rows.length; ++i ) {
if (Rows[i].className == RowClass) {		if (Rows[i].className == RowClass) {
Show All 38 Lines	else {
NumUnchecked++;		NumUnchecked++;
returnObjById("AllBugsCheck").checked = false;		returnObjById("AllBugsCheck").checked = false;
}		}
}		}
</script>		</script>
<!-- SUMMARYENDHEAD -->		<!-- SUMMARYENDHEAD -->
</head>		</head>
<body>		<body>
<h1>${HtmlTitle}</h1>		<h1>${Options{HtmlTitle}}</h1>

<table>		<table>
<tr><th>User:</th><td>${UserName}\@${HostName}</td></tr>		<tr><th>User:</th><td>${UserName}\@${HostName}</td></tr>
<tr><th>Working Directory:</th><td>${CurrentDir}</td></tr>		<tr><th>Working Directory:</th><td>${CurrentDir}</td></tr>
<tr><th>Command Line:</th><td>${CmdArgs}</td></tr>		<tr><th>Command Line:</th><td>${CmdArgs}</td></tr>
<tr><th>Clang Version:</th><td>${ClangVersion}</td></tr>		<tr><th>Clang Version:</th><td>${ClangVersion}</td></tr>
<tr><th>Date:</th><td>${Date}</td></tr>		<tr><th>Date:</th><td>${Date}</td></tr>
ENDTEXT		ENDTEXT
▲ Show 20 Lines • Show All 258 Lines • ▼ Show 20 Lines	sub AddIfNotPresent {
}		}

if ($found == 0) {		if ($found == 0) {
push @$Args, $Arg;		push @$Args, $Arg;
}		}
}		}

sub SetEnv {		sub SetEnv {
my $Options = shift @_;		my $EnvVars = shift @_;
foreach my $opt ('CC', 'CXX', 'CLANG', 'CLANG_CXX',		foreach my $var ('CC', 'CXX', 'CLANG', 'CLANG_CXX',
'CCC_ANALYZER_ANALYSIS', 'CCC_ANALYZER_PLUGINS',		'CCC_ANALYZER_ANALYSIS', 'CCC_ANALYZER_PLUGINS',
'CCC_ANALYZER_CONFIG') {		'CCC_ANALYZER_CONFIG') {
die "$opt is undefined\n" if (!defined $opt);		die "$var is undefined\n" if (!defined $var);
$ENV{$opt} = $Options->{$opt};		$ENV{$var} = $EnvVars->{$var};
}		}
foreach my $opt ('CCC_ANALYZER_STORE_MODEL',		foreach my $var ('CCC_ANALYZER_STORE_MODEL',
'CCC_ANALYZER_PLUGINS',		'CCC_ANALYZER_PLUGINS',
'CCC_ANALYZER_INTERNAL_STATS',		'CCC_ANALYZER_INTERNAL_STATS',
'CCC_ANALYZER_OUTPUT_FORMAT') {		'CCC_ANALYZER_OUTPUT_FORMAT',
my $x = $Options->{$opt};		'CCC_CC',
if (defined $x) { $ENV{$opt} = $x }		'CCC_CXX',
		'CCC_REPORT_FAILURES') {
		my $x = $EnvVars->{$var};
		if (defined $x) { $ENV{$var} = $x }
}		}
my $Verbose = $Options->{'VERBOSE'};		my $Verbose = $EnvVars->{'VERBOSE'};
if ($Verbose >= 2) {		if ($Verbose >= 2) {
$ENV{'CCC_ANALYZER_VERBOSE'} = 1;		$ENV{'CCC_ANALYZER_VERBOSE'} = 1;
}		}
if ($Verbose >= 3) {		if ($Verbose >= 3) {
$ENV{'CCC_ANALYZER_LOG'} = 1;		$ENV{'CCC_ANALYZER_LOG'} = 1;
}		}
}		}

# The flag corresponding to the --override-compiler command line option.
my $OverrideCompiler = 0;

sub RunXcodebuild {		sub RunXcodebuild {
my $Args = shift;		my $Args = shift;
my $IgnoreErrors = shift;		my $IgnoreErrors = shift;
my $CCAnalyzer = shift;		my $CCAnalyzer = shift;
my $CXXAnalyzer = shift;		my $CXXAnalyzer = shift;
my $Options = shift;		my $EnvVars = shift;

if ($IgnoreErrors) {		if ($IgnoreErrors) {
AddIfNotPresent($Args,"-PBXBuildsContinueAfterErrors=YES");		AddIfNotPresent($Args,"-PBXBuildsContinueAfterErrors=YES");
}		}

# Detect the version of Xcode. If Xcode 4.6 or higher, use new		# Detect the version of Xcode. If Xcode 4.6 or higher, use new
# in situ support for analyzer interposition without needed to override		# in situ support for analyzer interposition without needed to override
# the compiler.		# the compiler.
Show All 12 Lines	if (/^Xcode (.+)$/) {
}		}
}		}
}		}
}		}
close(DETECT_XCODE);		close(DETECT_XCODE);

# If --override-compiler is explicitely requested, resort to the old		# If --override-compiler is explicitely requested, resort to the old
# behavior regardless of Xcode version.		# behavior regardless of Xcode version.
if ($OverrideCompiler) {		if ($Options{OverrideCompiler}) {
$oldBehavior = 1;		$oldBehavior = 1;
}		}

if ($oldBehavior == 0) {		if ($oldBehavior == 0) {
my $OutputDir = $Options->{"OUTPUT_DIR"};		my $OutputDir = $EnvVars->{"OUTPUT_DIR"};
my $CLANG = $Options->{"CLANG"};		my $CLANG = $EnvVars->{"CLANG"};
my $OtherFlags = $Options->{"CCC_ANALYZER_ANALYSIS"};		my $OtherFlags = $EnvVars->{"CCC_ANALYZER_ANALYSIS"};
push @$Args,		push @$Args,
"RUN_CLANG_STATIC_ANALYZER=YES",		"RUN_CLANG_STATIC_ANALYZER=YES",
"CLANG_ANALYZER_OUTPUT=plist-html",		"CLANG_ANALYZER_OUTPUT=plist-html",
"CLANG_ANALYZER_EXEC=$CLANG",		"CLANG_ANALYZER_EXEC=$CLANG",
"CLANG_ANALYZER_OUTPUT_DIR=$OutputDir",		"CLANG_ANALYZER_OUTPUT_DIR=$OutputDir",
"CLANG_ANALYZER_OTHER_FLAGS=$OtherFlags";		"CLANG_ANALYZER_OTHER_FLAGS=$OtherFlags";

return (system(@$Args) >> 8);		return (system(@$Args) >> 8);
}		}

# Default to old behavior where we insert a bogus compiler.		# 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		# Check if using iPhone SDK 3.0 (simulator). If so the compiler being
# used should be gcc-4.2.		# used should be gcc-4.2.
if (!defined $ENV{"CCC_CC"}) {		if (!defined $ENV{"CCC_CC"}) {
for (my $i = 0 ; $i < scalar(@$Args); ++$i) {		for (my $i = 0 ; $i < scalar(@$Args); ++$i) {
if ($Args->[$i] eq "-sdk" && $i + 1 < scalar(@$Args)) {		if ($Args->[$i] eq "-sdk" && $i + 1 < scalar(@$Args)) {
if (@$Args[$i+1] =~ /^iphonesimulator3/) {		if (@$Args[$i+1] =~ /^iphonesimulator3/) {
$ENV{"CCC_CC"} = "gcc-4.2";		$ENV{"CCC_CC"} = "gcc-4.2";
Show All 15 Lines
}		}

sub RunBuildCommand {		sub RunBuildCommand {
my $Args = shift;		my $Args = shift;
my $IgnoreErrors = shift;		my $IgnoreErrors = shift;
my $Cmd = $Args->[0];		my $Cmd = $Args->[0];
my $CCAnalyzer = shift;		my $CCAnalyzer = shift;
my $CXXAnalyzer = shift;		my $CXXAnalyzer = shift;
my $Options = shift;		my $EnvVars = shift;

if ($Cmd =~ /\bxcodebuild$/) {		if ($Cmd =~ /\bxcodebuild$/) {
return RunXcodebuild($Args, $IgnoreErrors, $CCAnalyzer, $CXXAnalyzer, $Options);		return RunXcodebuild($Args, $IgnoreErrors, $CCAnalyzer, $CXXAnalyzer, $EnvVars);
}		}

# Setup the environment.		# Setup the environment.
SetEnv($Options);		SetEnv($EnvVars);

if ($Cmd =~ /(.\/?gcc[^\/]$)/ or		if ($Cmd =~ /(.\/?gcc[^\/]$)/ or
$Cmd =~ /(.\/?cc[^\/]$)/ or		$Cmd =~ /(.\/?cc[^\/]$)/ or
$Cmd =~ /(.\/?llvm-gcc[^\/]$)/ or		$Cmd =~ /(.\/?llvm-gcc[^\/]$)/ or
$Cmd =~ /(.*\/?clang$)/ or		$Cmd =~ /(.*\/?clang$)/ or
$Cmd =~ /(.\/?ccc-analyzer[^\/]$)/) {		$Cmd =~ /(.\/?ccc-analyzer[^\/]$)/) {

if (!($Cmd =~ /ccc-analyzer/) and !defined $ENV{"CCC_CC"}) {		if (!($Cmd =~ /ccc-analyzer/) and !defined $ENV{"CCC_CC"}) {
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
-load-plugin [plugin library]		-load-plugin [plugin library]
ENDTEXT		ENDTEXT

# Query clang for list of checkers that are enabled.		# Query clang for list of checkers that are enabled.

# create a list to load the plugins via the 'Xclang' command line		# create a list to load the plugins via the 'Xclang' command line
# argument		# argument
my @PluginLoadCommandline_xclang;		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, "-Xclang" );
push ( @PluginLoadCommandline_xclang, $param );		push ( @PluginLoadCommandline_xclang, $param );
}		}
my %EnabledCheckers;		my %EnabledCheckers;
foreach my $lang ("c", "objective-c", "objective-c++", "c++") {		foreach my $lang ("c", "objective-c", "objective-c++", "c++") {
pipe(FROM_CHILD, TO_PARENT);		pipe(FROM_CHILD, TO_PARENT);
my $pid = fork();		my $pid = fork();
if ($pid == 0) {		if ($pid == 0) {
Show All 11 Lines	while(<FROM_CHILD>) {
}		}
}		}
}		}
waitpid($pid,0);		waitpid($pid,0);
close(FROM_CHILD);		close(FROM_CHILD);
}		}

# Query clang for complete list of checkers.		# 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) {		if (defined $Clang && -x $Clang) {
pipe(FROM_CHILD, TO_PARENT);		pipe(FROM_CHILD, TO_PARENT);
my $pid = fork();		my $pid = fork();
if ($pid == 0) {		if ($pid == 0) {
close FROM_CHILD;		close FROM_CHILD;
open(STDOUT,">&", \*TO_PARENT);		open(STDOUT,">&", \*TO_PARENT);
open(STDERR,">&", \*TO_PARENT);		open(STDERR,">&", \*TO_PARENT);
exec $Clang, ('-cc1', @PluginsToLoad , '-analyzer-checker-help');		exec $Clang, ('-cc1', @PluginLoadCommandline, '-analyzer-checker-help');
}		}
close(TO_PARENT);		close(TO_PARENT);
my $foundCheckers = 0;		my $foundCheckers = 0;
while(<FROM_CHILD>) {		while(<FROM_CHILD>) {
if (/CHECKERS:/) {		if (/CHECKERS:/) {
$foundCheckers = 1;		$foundCheckers = 1;
last;		last;
}		}
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines	sub ShellEscape {
if ($arg =~ /["\s]/) { return "'" . $arg . "'"; }		if ($arg =~ /["\s]/) { return "'" . $arg . "'"; }
return $arg;		return $arg;
}		}

##----------------------------------------------------------------------------##		##----------------------------------------------------------------------------##
# Process command-line arguments.		# 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 $RequestDisplayHelp = 0;
my $ForceDisplayHelp = 0;		my $ForceDisplayHelp = 0;
my $AnalyzerDiscoveryMethod;

if (!@ARGV) {		sub ProcessArgs {
$ForceDisplayHelp = 1		my $Args = shift;
}

while (@ARGV) {		while (@$Args) {

# Scan for options we recognize.		# Scan for options we recognize.

my $arg = $ARGV[0];		my $arg = $Args->[0];

if ($arg eq "-h" or $arg eq "--help") {		if ($arg eq "-h" or $arg eq "--help") {
$RequestDisplayHelp = 1;		$RequestDisplayHelp = 1;
shift @ARGV;		shift @$Args;
next;		next;
}		}

if ($arg eq '-analyze-headers') {		if ($arg eq '-analyze-headers') {
shift @ARGV;		shift @$Args;
$AnalyzeHeaders = 1;		$Options{AnalyzeHeaders} = 1;
next;		next;
}		}

if ($arg eq "-o") {		if ($arg eq "-o") {
shift @ARGV;		shift @$Args;

if (!@ARGV) {		if (!@$Args) {
DieDiag("'-o' option requires a target directory name.\n");		DieDiag("'-o' option requires a target directory name.\n");
}		}

# Construct an absolute path. Uses the current working directory		# Construct an absolute path. Uses the current working directory
# as a base if the original path was not absolute.		# as a base if the original path was not absolute.
$HtmlDir = abs_path(shift @ARGV);		$Options{OutputDir} = abs_path(shift @$Args);

next;		next;
}		}

if ($arg =~ /^--html-title(=(.+))?$/) {		if ($arg =~ /^--html-title(=(.+))?$/) {
shift @ARGV;		shift @$Args;

if (!defined $2 \|\| $2 eq '') {		if (!defined $2 \|\| $2 eq '') {
if (!@ARGV) {		if (!@$Args) {
DieDiag("'--html-title' option requires a string.\n");		DieDiag("'--html-title' option requires a string.\n");
}		}

$HtmlTitle = shift @ARGV;		$Options{HtmlTitle} = shift @$Args;
} else {		} else {
$HtmlTitle = $2;		$Options{HtmlTitle} = $2;
}		}

next;		next;
}		}

if ($arg eq "-k" or $arg eq "--keep-going") {		if ($arg eq "-k" or $arg eq "--keep-going") {
shift @ARGV;		shift @$Args;
$IgnoreErrors = 1;		$Options{IgnoreErrors} = 1;
next;		next;
}		}

if ($arg =~ /^--use-cc(=(.+))?$/) {		if ($arg =~ /^--use-cc(=(.+))?$/) {
shift @ARGV;		shift @$Args;
my $cc;		my $cc;

if (!defined $2 \|\| $2 eq "") {		if (!defined $2 \|\| $2 eq "") {
if (!@ARGV) {		if (!@$Args) {
DieDiag("'--use-cc' option requires a compiler executable name.\n");		DieDiag("'--use-cc' option requires a compiler executable name.\n");
}		}
$cc = shift @ARGV;		$cc = shift @$Args;
}		}
else {		else {
$cc = $2;		$cc = $2;
}		}

$ENV{"CCC_CC"} = $cc;		$Options{UseCC} = $cc;
next;		next;
}		}

if ($arg =~ /^--use-c\+\+(=(.+))?$/) {		if ($arg =~ /^--use-c\+\+(=(.+))?$/) {
shift @ARGV;		shift @$Args;
my $cxx;		my $cxx;

if (!defined $2 \|\| $2 eq "") {		if (!defined $2 \|\| $2 eq "") {
if (!@ARGV) {		if (!@$Args) {
DieDiag("'--use-c++' option requires a compiler executable name.\n");		DieDiag("'--use-c++' option requires a compiler executable name.\n");
}		}
$cxx = shift @ARGV;		$cxx = shift @$Args;
}		}
else {		else {
$cxx = $2;		$cxx = $2;
}		}

$ENV{"CCC_CXX"} = $cxx;		$Options{UseCXX} = $cxx;
next;		next;
}		}

if ($arg eq "-v") {		if ($arg eq "-v") {
shift @ARGV;		shift @$Args;
$Verbose++;		$Options{Verbose}++;
next;		next;
}		}

if ($arg eq "-V" or $arg eq "--view") {		if ($arg eq "-V" or $arg eq "--view") {
shift @ARGV;		shift @$Args;
$ViewResults = 1;		$Options{ViewResults} = 1;
next;		next;
}		}

if ($arg eq "--status-bugs") {		if ($arg eq "--status-bugs") {
shift @ARGV;		shift @$Args;
$ExitStatusFoundBugs = 1;		$Options{ExitStatusFoundBugs} = 1;
next;		next;
}		}

if ($arg eq "-store") {		if ($arg eq "-store") {
shift @ARGV;		shift @$Args;
$StoreModel = shift @ARGV;		$Options{StoreModel} = shift @$Args;
next;		next;
}		}

if ($arg eq "-constraints") {		if ($arg eq "-constraints") {
shift @ARGV;		shift @$Args;
$ConstraintsModel = shift @ARGV;		$Options{ConstraintsModel} = shift @$Args;
next;		next;
}		}

if ($arg eq "-internal-stats") {		if ($arg eq "-internal-stats") {
shift @ARGV;		shift @$Args;
$InternalStats = 1;		$Options{InternalStats} = 1;
next;		next;
}		}

if ($arg eq "-plist") {		if ($arg eq "-plist") {
shift @ARGV;		shift @$Args;
$OutputFormat = "plist";		$Options{OutputFormat} = "plist";
next;		next;
}		}

if ($arg eq "-plist-html") {		if ($arg eq "-plist-html") {
shift @ARGV;		shift @$Args;
$OutputFormat = "plist-html";		$Options{OutputFormat} = "plist-html";
next;		next;
}		}

if ($arg eq "-analyzer-config") {		if ($arg eq "-analyzer-config") {
shift @ARGV;		shift @$Args;
push @ConfigOptions, "-analyzer-config", shift @ARGV;		push @{$Options{ConfigOptions}}, shift @$Args;
next;		next;
}		}

if ($arg eq "-no-failure-reports") {		if ($arg eq "-no-failure-reports") {
shift @ARGV;		shift @$Args;
$ENV{"CCC_REPORT_FAILURES"} = 0;		$Options{ReportFailures} = 0;
next;		next;
}		}

if ($arg eq "-stats") {		if ($arg eq "-stats") {
shift @ARGV;		shift @$Args;
$AnalyzerStats = 1;		$Options{AnalyzerStats} = 1;
next;		next;
}		}

if ($arg eq "-maxloop") {		if ($arg eq "-maxloop") {
shift @ARGV;		shift @$Args;
$MaxLoop = shift @ARGV;		$Options{MaxLoop} = shift @$Args;
next;		next;
}		}

if ($arg eq "-enable-checker") {		if ($arg eq "-enable-checker") {
shift @ARGV;		shift @$Args;
push @AnalysesToRun, "-analyzer-checker", shift @ARGV;		push @{$Options{EnableCheckers}}, shift @$Args;
next;		next;
}		}

if ($arg eq "-disable-checker") {		if ($arg eq "-disable-checker") {
shift @ARGV;		shift @$Args;
push @AnalysesToRun, "-analyzer-disable-checker", shift @ARGV;		push @{$Options{DisableCheckers}}, shift @$Args;
next;		next;
}		}

if ($arg eq "-load-plugin") {		if ($arg eq "-load-plugin") {
shift @ARGV;		shift @$Args;
push @PluginsToLoad, "-load", shift @ARGV;		push @{$Options{PluginsToLoad}}, shift @$Args;
next;		next;
}		}

if ($arg eq "--use-analyzer") {		if ($arg eq "--use-analyzer") {
shift @ARGV;		shift @$Args;
$AnalyzerDiscoveryMethod = shift @ARGV;		$Options{AnalyzerDiscoveryMethod} = shift @$Args;
next;		next;
}		}

if ($arg =~ /^--use-analyzer=(.+)$/) {		if ($arg =~ /^--use-analyzer=(.+)$/) {
shift @ARGV;		shift @$Args;
$AnalyzerDiscoveryMethod = $1;		$Options{AnalyzerDiscoveryMethod} = $1;
next;		next;
}		}

if ($arg eq "--keep-empty") {		if ($arg eq "--keep-empty") {
shift @ARGV;		shift @$Args;
$KeepEmpty = 1;		$Options{KeepEmpty} = 1;
next;		next;
}		}

if ($arg eq "--override-compiler") {		if ($arg eq "--override-compiler") {
shift @ARGV;		shift @$Args;
$OverrideCompiler = 1;		$Options{OverrideCompiler} = 1;
next;		next;
}		}

DieDiag("unrecognized option '$arg'\n") if ($arg =~ /^-/);		DieDiag("unrecognized option '$arg'\n") if ($arg =~ /^-/);

last;		last;
}		}
		}

		if (!@ARGV) {
		$ForceDisplayHelp = 1
		}

		ProcessArgs(\@ARGV);

if (!@ARGV and !$RequestDisplayHelp) {		if (!@ARGV and !$RequestDisplayHelp) {
ErrorDiag("No build command specified.\n\n");		ErrorDiag("No build command specified.\n\n");
$ForceDisplayHelp = 1;		$ForceDisplayHelp = 1;
}		}

# Find 'clang'		# Find 'clang'
if (!defined $AnalyzerDiscoveryMethod) {		if (!defined $Options{AnalyzerDiscoveryMethod}) {
$Clang = Cwd::realpath("$RealBin/bin/clang");		$Clang = Cwd::realpath("$RealBin/bin/clang");
if (!defined $Clang \|\| ! -x $Clang) {		if (!defined $Clang \|\| ! -x $Clang) {
$Clang = Cwd::realpath("$RealBin/clang");		$Clang = Cwd::realpath("$RealBin/clang");
}		}
if (!defined $Clang \|\| ! -x $Clang) {		if (!defined $Clang \|\| ! -x $Clang) {
if (!$RequestDisplayHelp && !$ForceDisplayHelp) {		if (!$RequestDisplayHelp && !$ForceDisplayHelp) {
DieDiag("error: Cannot find an executable 'clang' relative to scan-build." .		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");		" Consider using --use-analyzer to pick a version of 'clang' to use for static analysis.\n");
}		}
}		}
}		}
else {		else {
if ($AnalyzerDiscoveryMethod =~ /^[Xx]code$/) {		if ($Options{AnalyzerDiscoveryMethod} =~ /^[Xx]code$/) {
my $xcrun = `which xcrun`;		my $xcrun = `which xcrun`;
chomp $xcrun;		chomp $xcrun;
if ($xcrun eq "") {		if ($xcrun eq "") {
DieDiag("Cannot find 'xcrun' to find 'clang' for analysis.\n");		DieDiag("Cannot find 'xcrun' to find 'clang' for analysis.\n");
}		}
$Clang = `$xcrun -toolchain XcodeDefault -find clang`;		$Clang = `$xcrun -toolchain XcodeDefault -find clang`;
chomp $Clang;		chomp $Clang;
if ($Clang eq "") {		if ($Clang eq "") {
DieDiag("No 'clang' executable found by 'xcrun'\n");		DieDiag("No 'clang' executable found by 'xcrun'\n");
}		}
}		}
else {		else {
$Clang = $AnalyzerDiscoveryMethod;		$Clang = $Options{AnalyzerDiscoveryMethod};
if (!defined $Clang or not -x $Clang) {		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) {		if ($ForceDisplayHelp \|\| $RequestDisplayHelp) {
DisplayHelp();		DisplayHelp();
exit $ForceDisplayHelp;		exit $ForceDisplayHelp;
}		}
Show All 9 Lines	else {
$ClangCXX .= "++";		$ClangCXX .= "++";
}		}

# Make sure to use "" to handle paths with spaces.		# Make sure to use "" to handle paths with spaces.
$ClangVersion = HtmlEscape(`"$Clang" --version`);		$ClangVersion = HtmlEscape(`"$Clang" --version`);

# Determine where results go.		# Determine where results go.
$CmdArgs = HtmlEscape(join(' ', map(ShellEscape($_), @ARGV)));		$CmdArgs = HtmlEscape(join(' ', map(ShellEscape($_), @ARGV)));
$HtmlTitle = "${CurrentDirSuffix} - scan-build results"
unless (defined($HtmlTitle));

# Determine the output directory for the HTML reports.		# Determine the output directory for the HTML reports.
my $BaseDir = $HtmlDir;		my $BaseDir = $Options{OutputDir};
$HtmlDir = GetHTMLRunDir($HtmlDir);		$Options{OutputDir} = GetHTMLRunDir($Options{OutputDir});

# Determine the location of ccc-analyzer.		# Determine the location of ccc-analyzer.
my $AbsRealBin = Cwd::realpath($RealBin);		my $AbsRealBin = Cwd::realpath($RealBin);
my $Cmd = "$AbsRealBin/libexec/ccc-analyzer";		my $Cmd = "$AbsRealBin/libexec/ccc-analyzer";
my $CmdCXX = "$AbsRealBin/libexec/c++-analyzer";		my $CmdCXX = "$AbsRealBin/libexec/c++-analyzer";

# Portability: use less strict but portable check -e (file exists) instead of		# 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		# 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		# file extension to determine if a file is executable (see Perl language
# reference, perlport)		# reference, perlport)
if (!defined $Cmd \|\| ! -e $Cmd) {		if (!defined $Cmd \|\| ! -e $Cmd) {
$Cmd = "$AbsRealBin/ccc-analyzer";		$Cmd = "$AbsRealBin/ccc-analyzer";
DieDiag("'ccc-analyzer' does not exist at '$Cmd'\n") if(! -e $Cmd);		DieDiag("'ccc-analyzer' does not exist at '$Cmd'\n") if(! -e $Cmd);
}		}
if (!defined $CmdCXX \|\| ! -e $CmdCXX) {		if (!defined $CmdCXX \|\| ! -e $CmdCXX) {
$CmdCXX = "$AbsRealBin/c++-analyzer";		$CmdCXX = "$AbsRealBin/c++-analyzer";
DieDiag("'c++-analyzer' does not exist at '$CmdCXX'\n") if(! -e $CmdCXX);		DieDiag("'c++-analyzer' does not exist at '$CmdCXX'\n") if(! -e $CmdCXX);
}		}

Diag("Using '$Clang' for static analysis\n");		Diag("Using '$Clang' for static analysis\n");

SetHtmlEnv(\@ARGV, $HtmlDir);		SetHtmlEnv(\@ARGV, $Options{OutputDir});
if ($AnalyzeHeaders) { push @AnalysesToRun,"-analyzer-opt-analyze-headers"; }
if ($AnalyzerStats) { push @AnalysesToRun, '-analyzer-checker=debug.Stats'; }		my @AnalysesToRun;
if ($MaxLoop > 0) { push @AnalysesToRun, "-analyzer-max-loop $MaxLoop"; }		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		# Delay setting up other environment variables in case we can do true
# interposition.		# interposition.
my $CCC_ANALYZER_ANALYSIS = join ' ',@AnalysesToRun;		my $CCC_ANALYZER_ANALYSIS = join ' ', @AnalysesToRun;
my $CCC_ANALYZER_PLUGINS = join ' ',@PluginsToLoad;		my $CCC_ANALYZER_PLUGINS = join ' ', map { "-load ".$_ } @{$Options{PluginsToLoad}};
my $CCC_ANALYZER_CONFIG = join ' ',@ConfigOptions;		my $CCC_ANALYZER_CONFIG = join ' ', map { "-analyzer-config ".$_ } @{$Options{ConfigOptions}};
my %Options = (		my %EnvVars = (
'CC' => $Cmd,		'CC' => $Cmd,
'CXX' => $CmdCXX,		'CXX' => $CmdCXX,
'CLANG' => $Clang,		'CLANG' => $Clang,
'CLANG_CXX' => $ClangCXX,		'CLANG_CXX' => $ClangCXX,
'VERBOSE' => $Verbose,		'VERBOSE' => $Options{Verbose},
'CCC_ANALYZER_ANALYSIS' => $CCC_ANALYZER_ANALYSIS,		'CCC_ANALYZER_ANALYSIS' => $CCC_ANALYZER_ANALYSIS,
'CCC_ANALYZER_PLUGINS' => $CCC_ANALYZER_PLUGINS,		'CCC_ANALYZER_PLUGINS' => $CCC_ANALYZER_PLUGINS,
'CCC_ANALYZER_CONFIG' => $CCC_ANALYZER_CONFIG,		'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},
);		);

if (defined $StoreModel) {		if (defined $Options{StoreModel}) {
$Options{'CCC_ANALYZER_STORE_MODEL'} = $StoreModel;		$EnvVars{'CCC_ANALYZER_STORE_MODEL'} = $Options{StoreModel};
}		}
if (defined $ConstraintsModel) {		if (defined $Options{ConstraintsModel}) {
$Options{'CCC_ANALYZER_CONSTRAINTS_MODEL'} = $ConstraintsModel;		$EnvVars{'CCC_ANALYZER_CONSTRAINTS_MODEL'} = $Options{ConstraintsModel};
}		}
if (defined $InternalStats) {		if (defined $Options{InternalStats}) {
$Options{'CCC_ANALYZER_INTERNAL_STATS'} = 1;		$EnvVars{'CCC_ANALYZER_INTERNAL_STATS'} = $Options{InternalStats};
}		}
if (defined $OutputFormat) {		if (defined $Options{OutputFormat}) {
$Options{'CCC_ANALYZER_OUTPUT_FORMAT'} = $OutputFormat;		$EnvVars{'CCC_ANALYZER_OUTPUT_FORMAT'} = $Options{OutputFormat};
}		}

# Run the build.		# Run the build.
my $ExitStatus = RunBuildCommand(\@ARGV, $IgnoreErrors, $Cmd, $CmdCXX,		my $ExitStatus = RunBuildCommand(\@ARGV, $Options{IgnoreErrors}, $Cmd, $CmdCXX,
\%Options);		\%EnvVars);

if (defined $OutputFormat) {		if (defined $Options{OutputFormat}) {
if ($OutputFormat =~ /plist/) {		if ($Options{OutputFormat} =~ /plist/) {
Diag "Analysis run complete.\n";		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.		# 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 "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");		my $ScanView = Cwd::realpath("$RealBin/scan-view");
if (! -x $ScanView) { $ScanView = "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 1 if ($NumBugs > 0);
exit 0;		exit 0;
}		}
}		}
}		}

exit $ExitStatus;		exit $ExitStatus;

This is an archive of the discontinued LLVM Phabricator instance.

Improvements to scan-build.
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 22727

tools/scan-build/scan-build

This is an archive of the discontinued LLVM Phabricator instance.

Improvements to scan-build.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 22727

tools/scan-build/scan-build

Improvements to scan-build.
ClosedPublic