mercury/tools/linear

#!/bin/sh
# This script finds miscompiled procedures.
#
# Given a stage2 directory that works (stage2.ok) and one that doesn't
# (stage2.bad), this script uses linear search to try to find in stage2.bad
# first the C source file and then the module within that C source file that
# when put together with everthing else from the stage2.ok directory, still
# causes the compiler to fail.
#
# If the bad C source file has different numbers of modules in the bad and ok
# versions, then the script stops after identifying only the file.
#
# The test for the composite stage2 compiler is either bootstrap checking
# (the default, or the successful execution of the all the test cases in
# one or more dubdirectories of the tests directory.

usage="\
Usage: $0 [options]
Options:
	-b, --no-bootcheck
		Do not perform a bootcheck; check only the tests directory.
	-c, --compile-only
		Compile only. Do not compare stage2.ok and stage3.
	-d <dirname>, --dir <dirname>
		Confine the search to one directory, library or compiler.
		(Usually useful only after a previous search.)
	-f <filename>, --file <filename>
		Confine the search to the named file(s).
		(Usually useful only after a previous search.)
	-h, --help
		Display this usage message.
	-j <num-jobs>, --jobs <num-jobs>
		Run using <num-jobs> different parallel processes.
	-m <mmake-args>, --mmake-args <mmake-args>
		Pass <mmake-args> as options to \`mmake'.
	-n, --negative-search
		Look for the module that suppresses the bug, not causes it.
	-o <filename>, --output-file <filename>
		Output results to <filename>.
	-r, --copy-runtime
		Copy the runtime directory instead of linking it.
	-t <testdir>, --test-dir <testdir>
		Execute runtests from the named subdirectory of tests.
"

bootcheck=""
compile_only=""
jfactor=
mmake_opts=""
outfile=""
copy_runtime=false
testdirs=""
negative=false
alldirs="library compiler"
allmodules=""

while [ $# -gt 0 ]; do
	case "$1" in

	-b|--no-bootcheck)
		bootcheck="-b" ;;

	-c|--compile-only)
		compile_only="-c" ;;

	-d|--dir)
		alldirs="$2"; shift ;;
	-d*)
		alldirs="` expr $1 : '-d\(.*\)' `"; ;;

	-f|--file)
		allmodules="$2"; shift ;;
	-f*)
		allmodules="` expr $1 : '-f\(.*\)' `"; ;;

	-h|--help)
		echo "$usage"
		exit 0 ;;

	-j|--jobs)
		jfactor="-j$2"; shift ;;
	-j*)
		jfactor="-j` expr $1 : '-j\(.*\)' `" ;;
	--jobs*)
		jfactor="--jobs ` expr $1 : '--jobs\(.*\)' `" ;;

	-m|--mmake)
		mmake_opts="$mmake_opts $2"; shift ;;

	-n|--negative-search)
		negative=true ;;

	-o|--output-file)
		outfile="-o $2"; shift ;;
	-o*)
		outfile="-o ` expr $1 : '-o\(.*\)' `"; ;;

	-r|--copy-runtime)
		copy_runtime=true ;;

	-t|--test-dir)
		testdirs="$testdirs -t$2"; shift ;;
	-t*)
		testdirs="$testdirs ` expr $1 : '-t\(.*\)' `" ;;

	-*)
		echo "$0: unknown option \`$1'" 1>&2
		echo "$usage" 1>&2
		exit 1 ;;

	*)
		echo "$usage" 1>&2
		exit 1 ;;
	esac
	shift
done

if test "$negative" = true
then
	base=bad
	trial=ok
	expected=failure
else
	base=ok
	trial=bad
	expected=success
fi

if test -d stage2.ok -a -d stage2.bad
then
	echo "stage2.ok and stage2.bad both present"
else
	echo "at least one of stage2.ok and stage2.bad is missing"
	exit 1
fi

echo "starting at `date`"

root=`/bin/pwd`
PATH=$root/tools:$PATH
export PATH

[ -d stage2 ] || mkdir stage2
/bin/rm -fr stage2/*
cd stage2
mkdir compiler
cd $root/stage2/compiler
ln -s $root/compiler/*.m .
cp $root/compiler/Mmake* .
cd $root/stage2
mkdir library
cd library
ln -s $root/library/*.m .
# ln -s $root/library/*.nl .
ln -s $root/library/library.init .
cp $root/library/Mmake* .
cd $root/stage2
if test "$copy_runtime" = "true"
then
	mkdir runtime
	cd runtime
	ln -s $root/runtime/*.h .
	ln -s $root/runtime/*.c .
	ln -s $root/runtime/*.mod .
	ln -s $root/runtime/*.in .
	ln -s $root/runtime/machdeps .
	cp $root/runtime/Mmake* .
	cd $root/stage2
else
	ln -s $root/runtime .
fi
ln -s $root/boehm_gc .
ln -s $root/doc .
ln -s $root/scripts .
ln -s $root/util .
ln -s $root/profiler .
ln -s $root/conf* .
rm -f config*.log
cp $root/stage2.ok/Mmake* .
cd $root

# We don't copy the .d files. This prevents mmake from trying to remake any
# of the .c and .o files, which we provide in the form they should be used.

# cp stage2.ok/library/*.d stage2/library
cp stage2.ok/library/*.dep stage2/library
cp stage2.ok/library/*.int stage2/library
cp stage2.ok/library/*.int2 stage2/library
cp stage2.ok/library/*.date stage2/library
# cp stage2.ok/compiler/*.d stage2/compiler
cp stage2.ok/compiler/*.dep stage2/compiler
cp stage2.ok/compiler/*.int stage2/compiler
cp stage2.ok/compiler/*.int2 stage2/compiler
cp stage2.ok/compiler/*.date stage2/compiler

cp stage2.$base/library/*.[co] stage2/library
cp stage2.$base/compiler/*.[co] stage2/compiler

if test "$copy_runtime" = "true"
then
	if (cd stage2 ; mmake $mmake_opts $jfactor runtime)
	then
		echo "building of stage 2 runtime successful"
	else
		echo "building of stage 2 runtime not successful"
		exit 1
	fi
fi

set -x

normal=
unusual=
unusualparts=

for testeddir in $alldirs
do
	# find the set of modules to search, if not given on command line
	if test "$allmodules" = ""
	then
		cd stage2/$testeddir
		allmodules=`sub X.c X *.c`
		cd $root
	fi

	for testedmodule in $allmodules
	do
		# at this point, all the files in stage2
		# should be from stage2.$base

		echo "testing module: $testedmodule"

		cp stage2.$trial/$testeddir/$testedmodule.[co] stage2/$testeddir

		if binary_step $bootcheck $compile_only $jfactor -m "$mmake_opts" $outfile $testdirs
		then
			echo "test succeeded"
			lasttest=success
		else
			echo "test failed"
			lasttest=failure
		fi

		if test "$lasttest" = "$expected"
		then
			normal="$normal $testeddir/$testedmodule"
		else
			unusual="$unusual $testeddir/$testedmodule"

			basecnt=`egrep '^END_MODULE' stage2.$base/$testeddir/$testedmodule.c | wc -l`
			trialcnt=`egrep '^END_MODULE' stage2.$trial/$testeddir/$testedmodule.c | wc -l`

			if test $basecnt -ne $trialcnt
			then
				basecnt=`echo $basecnt | tr -d ' '`
				trialcnt=`echo $trialcnt | tr -d ' '`

				echo "the two versions of the unusual module"
				echo "differ in the number of C modules they have"
				echo "$base version: $basecnt vs $trial version: $trialcnt"
				exit 1
			fi

			for dir in $base $trial
			do
				cd stage2.$dir/$testeddir
				divide $testedmodule.c $basecnt
				cd $root
			done

			allparts=
			i=0
			while test $i -le $basecnt
			do
				allparts="$allparts $i"
				i=`expr $i + 1`
			done

			for testedpart in $allparts
			do
				echo testing part $testedpart in `/bin/pwd`
				assemble $base $trial $testeddir $testedmodule $basecnt $testedpart

				cd stage2/$testeddir
				/bin/rm $testedmodule.o
				mmake $testedmodule.o
				cd $root

				if binary_step $bootcheck $compile_only $jfactor -m "$mmake_opts" $outfile $testdirs
				then
					echo "test succeeded"
					lasttest=success
				else
					echo "test failed"
					lasttest=failure
				fi

				if test "$lasttest" != "$expected"
				then
					unusualparts="$unusualparts $testeddir/$testedmodule.part.$testedpart"
				fi
			done
		fi

		cp stage2.$base/$testeddir/$testedmodule.[co] stage2/$testeddir
	done
done

echo "modules whose stage.$trial versions behave as expected:"
echo $normal

echo "modules whose stage.$trial versions do not behave as expected:"
echo $unusual

echo "module parts whose stage.$trial versions do not behave as expected:"
echo $unusualparts

echo "finishing at `date`"
exit 0