mirror of
https://git.savannah.gnu.org/git/make.git
synced 2024-10-24 05:09:58 +00:00
6ccf33cdbd
string into the strcache. As a side-effect, many more structure members and function arguments can/should be declared const. As mentioned in the changelog, unfortunately measurement shows that this change does not yet reduce memory. The problem is with secondary expansion: because of this we store all the prerequisites in the string cache twice. First we store the prerequisite string after initial expansion but before secondary expansion, then we store each individual file after secondary expansion and expand_deps(). I plan to change expand_deps() to be callable in either context (eval or snap_deps) then have non-second-expansion targets call expand_deps() during eval, so that we only need to store that dependency list once.
356 lines
9.6 KiB
Perl
Executable file
356 lines
9.6 KiB
Perl
Executable file
#!/usr/bin/env perl
|
|
# -*-perl-*-
|
|
|
|
# Test driver for the Make test suite
|
|
|
|
# Usage: run_make_tests [testname]
|
|
# [-debug]
|
|
# [-help]
|
|
# [-verbose]
|
|
# [-keep]
|
|
# [-make <make prog>]
|
|
# (and others)
|
|
|
|
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
|
|
# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
|
|
# This file is part of GNU Make.
|
|
#
|
|
# GNU Make is free software; you can redistribute it and/or modify it under the
|
|
# terms of the GNU General Public License as published by the Free Software
|
|
# Foundation; either version 2, or (at your option) any later version.
|
|
#
|
|
# GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along with
|
|
# GNU Make; see the file COPYING. If not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
$valgrind = 0; # invoke make with valgrind
|
|
$valgrind_args = '--num-callers=15 --tool=memcheck --leak-check=full';
|
|
$pure_log = undef;
|
|
|
|
require "test_driver.pl";
|
|
|
|
# Some target systems might not have the POSIX module...
|
|
$has_POSIX = eval { require "POSIX.pm" };
|
|
|
|
#$SIG{INT} = sub { print STDERR "Caught a signal!\n"; die @_; };
|
|
|
|
sub valid_option
|
|
{
|
|
local($option) = @_;
|
|
|
|
if ($option =~ /^-make([-_]?path)?$/)
|
|
{
|
|
$make_path = shift @argv;
|
|
if (!-f $make_path)
|
|
{
|
|
print "$option $make_path: Not found.\n";
|
|
exit 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
if ($option =~ /^-valgrind$/i) {
|
|
$valgrind = 1;
|
|
return 1;
|
|
}
|
|
|
|
# This doesn't work--it _should_! Someone badly needs to fix this.
|
|
#
|
|
# elsif ($option =~ /^-work([-_]?dir)?$/)
|
|
# {
|
|
# $workdir = shift @argv;
|
|
# return 1;
|
|
# }
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
# This is an "all-in-one" function. Arguments are as follows:
|
|
#
|
|
# [0] (string): The makefile to be tested. undef means use the last one.
|
|
# [1] (string): Arguments to pass to make.
|
|
# [2] (string): Answer we should get back.
|
|
# [3] (integer): Exit code we expect. A missing code means 0 (success)
|
|
|
|
$old_makefile = undef;
|
|
|
|
sub run_make_test
|
|
{
|
|
local ($makestring, $options, $answer, $err_code) = @_;
|
|
|
|
# If the user specified a makefile string, create a new makefile to contain
|
|
# it. If the first value is not defined, use the last one (if there is
|
|
# one).
|
|
|
|
if (! defined $makestring) {
|
|
defined $old_makefile
|
|
|| die "run_make_test(undef) invoked before run_make_test('...')\n";
|
|
$makefile = $old_makefile;
|
|
} else {
|
|
if (! defined($makefile)) {
|
|
$makefile = &get_tmpfile();
|
|
}
|
|
|
|
# Make sure it ends in a newline.
|
|
$makestring && $makestring !~ /\n$/s and $makestring .= "\n";
|
|
|
|
# Replace @MAKEFILE@ with the makefile name and @MAKE@ with the path to
|
|
# make
|
|
$makestring =~ s/#MAKEFILE#/$makefile/g;
|
|
$makestring =~ s/#MAKEPATH#/$mkpath/g;
|
|
$makestring =~ s/#MAKE#/$make_name/g;
|
|
$makestring =~ s/#PWD#/$pwd/g;
|
|
|
|
# Populate the makefile!
|
|
open(MAKEFILE, "> $makefile") || die "Failed to open $makefile: $!\n";
|
|
print MAKEFILE $makestring;
|
|
close(MAKEFILE) || die "Failed to write $makefile: $!\n";
|
|
}
|
|
|
|
# Do the same processing on $answer as we did on $makestring.
|
|
|
|
$answer && $answer !~ /\n$/s and $answer .= "\n";
|
|
$answer =~ s/#MAKEFILE#/$makefile/g;
|
|
$answer =~ s/#MAKEPATH#/$mkpath/g;
|
|
$answer =~ s/#MAKE#/$make_name/g;
|
|
$answer =~ s/#PWD#/$pwd/g;
|
|
|
|
&run_make_with_options($makefile, $options, &get_logfile(0), $err_code);
|
|
&compare_output($answer, &get_logfile(1));
|
|
|
|
$old_makefile = $makefile;
|
|
$makefile = undef;
|
|
}
|
|
|
|
# The old-fashioned way...
|
|
sub run_make_with_options {
|
|
local ($filename,$options,$logname,$expected_code) = @_;
|
|
local($code);
|
|
local($command) = $make_path;
|
|
|
|
$expected_code = 0 unless defined($expected_code);
|
|
|
|
# Reset to reflect this one test.
|
|
$test_passed = 1;
|
|
|
|
if ($filename) {
|
|
$command .= " -f $filename";
|
|
}
|
|
|
|
if ($options) {
|
|
$command .= " $options";
|
|
}
|
|
|
|
if ($valgrind) {
|
|
print VALGRIND "\n\nExecuting: $command\n";
|
|
}
|
|
|
|
$code = &run_command_with_output($logname,$command);
|
|
|
|
# Check to see if we have Purify errors. If so, keep the logfile.
|
|
# For this to work you need to build with the Purify flag -exit-status=yes
|
|
|
|
if ($pure_log && -f $pure_log) {
|
|
if ($code & 0x7000) {
|
|
$code &= ~0x7000;
|
|
|
|
# If we have a purify log, save it
|
|
$tn = $pure_testname . ($num_of_logfiles ? ".$num_of_logfiles" : "");
|
|
print("Renaming purify log file to $tn\n") if $debug;
|
|
rename($pure_log, "$tn")
|
|
|| die "Can't rename $log to $tn: $!\n";
|
|
++$purify_errors;
|
|
} else {
|
|
unlink($pure_log);
|
|
}
|
|
}
|
|
|
|
if ($code != $expected_code) {
|
|
print "Error running $make_path (expected $expected_code; got $code): $command\n";
|
|
$test_passed = 0;
|
|
# If it's a SIGINT, stop here
|
|
if ($code & 127) {
|
|
print STDERR "\nCaught signal ".($code & 127)."!\n";
|
|
exit($code);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if ($profile & $vos) {
|
|
system "add_profile $make_path";
|
|
}
|
|
|
|
1;
|
|
}
|
|
|
|
sub print_usage
|
|
{
|
|
&print_standard_usage ("run_make_tests",
|
|
"[-make_path make_pathname] [-valgrind]",);
|
|
}
|
|
|
|
sub print_help
|
|
{
|
|
&print_standard_help ("-make_path",
|
|
"\tYou may specify the pathname of the copy of make to run.");
|
|
}
|
|
|
|
sub get_this_pwd {
|
|
$delete_command = 'rm -f';
|
|
if ($has_POSIX) {
|
|
$__pwd = POSIX::getcwd();
|
|
} elsif ($vos) {
|
|
$delete_command = "delete_file -no_ask";
|
|
$__pwd = `++(current_dir)`;
|
|
} else {
|
|
# No idea... just try using pwd as a last resort.
|
|
chop ($__pwd = `pwd`);
|
|
}
|
|
|
|
return $__pwd;
|
|
}
|
|
|
|
sub set_defaults
|
|
{
|
|
# $profile = 1;
|
|
$testee = "GNU make";
|
|
$make_path = "make";
|
|
$tmpfilesuffix = "mk";
|
|
$pwd = &get_this_pwd;
|
|
}
|
|
|
|
sub set_more_defaults
|
|
{
|
|
local($string);
|
|
local($index);
|
|
|
|
# find the type of the port. We do this up front to have a single
|
|
# point of change if it needs to be tweaked.
|
|
#
|
|
# This is probably not specific enough.
|
|
#
|
|
if ($osname =~ /Windows/i || $osname =~ /MINGW32/i || $osname =~ /CYGWIN_NT/i) {
|
|
$port_type = 'W32';
|
|
}
|
|
# Bleah, the osname is so variable on DOS. This kind of bites.
|
|
# Well, as far as I can tell if we check for some text at the
|
|
# beginning of the line with either no spaces or a single space, then
|
|
# a D, then either "OS", "os", or "ev" and a space. That should
|
|
# match and be pretty specific.
|
|
elsif ($osname =~ /^([^ ]*|[^ ]* [^ ]*)D(OS|os|ev) /) {
|
|
$port_type = 'DOS';
|
|
}
|
|
# Check for OS/2
|
|
elsif ($osname =~ m%OS/2%) {
|
|
$port_type = 'OS/2';
|
|
}
|
|
# Everything else, right now, is UNIX. Note that we should integrate
|
|
# the VOS support into this as well and get rid of $vos; we'll do
|
|
# that next time.
|
|
else {
|
|
$port_type = 'UNIX';
|
|
}
|
|
|
|
# On DOS/Windows system the filesystem apparently can't track
|
|
# timestamps with second granularity (!!). Change the sleep time
|
|
# needed to force a file to be considered "old".
|
|
$wtime = $port_type eq 'UNIX' ? 1 : $port_type eq 'OS/2' ? 2 : 4;
|
|
|
|
print "Port type: $port_type\n" if $debug;
|
|
print "Make path: $make_path\n" if $debug;
|
|
|
|
# Find the full pathname of Make. For DOS systems this is more
|
|
# complicated, so we ask make itself.
|
|
my $mk = `sh -c 'echo "all:;\@echo \\\$(MAKE)" | $make_path -f-'`;
|
|
chop $mk;
|
|
$mk or die "FATAL ERROR: Cannot determine the value of \$(MAKE):\n
|
|
'echo \"all:;\@echo \\\$(MAKE)\" | $make_path -f-' failed!\n";
|
|
$make_path = $mk;
|
|
print "Make\t= `$make_path'\n" if $debug;
|
|
|
|
$string = `$make_path -v -f /dev/null 2> /dev/null`;
|
|
|
|
$string =~ /^(GNU Make [^,\n]*)/;
|
|
$testee_version = "$1\n";
|
|
|
|
$string = `sh -c "$make_path -f /dev/null 2>&1"`;
|
|
if ($string =~ /(.*): \*\*\* No targets\. Stop\./) {
|
|
$make_name = $1;
|
|
}
|
|
else {
|
|
if ($make_path =~ /$pathsep([^\n$pathsep]*)$/) {
|
|
$make_name = $1;
|
|
}
|
|
else {
|
|
$make_name = $make_path;
|
|
}
|
|
}
|
|
|
|
# prepend pwd if this is a relative path (ie, does not
|
|
# start with a slash, but contains one). Thanks for the
|
|
# clue, Roland.
|
|
|
|
if (index ($make_path, ":") != 1 && index ($make_path, "/") > 0)
|
|
{
|
|
$mkpath = "$pwd$pathsep$make_path";
|
|
}
|
|
else
|
|
{
|
|
$mkpath = $make_path;
|
|
}
|
|
|
|
# Get Purify log info--if any.
|
|
|
|
if (exists $ENV{PURIFYOPTIONS}
|
|
&& $ENV{PURIFYOPTIONS} =~ /.*-logfile=([^ ]+)/) {
|
|
$pure_log = $1 || '';
|
|
$pure_log =~ s/%v/$make_name/;
|
|
$purify_errors = 0;
|
|
}
|
|
|
|
$string = `sh -c "$make_path -j 2 -f /dev/null 2>&1"`;
|
|
if ($string =~ /not supported/) {
|
|
$parallel_jobs = 0;
|
|
}
|
|
else {
|
|
$parallel_jobs = 1;
|
|
}
|
|
|
|
# Set up for valgrind, if requested.
|
|
|
|
if ($valgrind) {
|
|
open(VALGRIND, "> valgrind.out")
|
|
|| die "Cannot open valgrind.out: $!\n";
|
|
# -q --leak-check=yes
|
|
exists $ENV{VALGRIND_ARGS} and $valgrind_args = $ENV{VALGRIND_ARGS};
|
|
$make_path = "valgrind --log-fd=".fileno(VALGRIND)." $valgrind_args $make_path";
|
|
# F_SETFD is 2
|
|
fcntl(VALGRIND, 2, 0) or die "fcntl(setfd) failed: $!\n";
|
|
system("echo Starting on `date` 1>&".fileno(VALGRIND));
|
|
print "Enabled valgrind support.\n";
|
|
}
|
|
}
|
|
|
|
sub setup_for_test
|
|
{
|
|
$makefile = &get_tmpfile;
|
|
if (-f $makefile) {
|
|
unlink $makefile;
|
|
}
|
|
|
|
# Get rid of any Purify logs.
|
|
if ($pure_log) {
|
|
($pure_testname = $testname) =~ tr,/,_,;
|
|
$pure_testname = "$pure_log.$pure_testname";
|
|
system("rm -f $pure_testname*");
|
|
print("Purify testfiles are: $pure_testname*\n") if $debug;
|
|
}
|
|
}
|
|
|
|
exit !&toplevel;
|