Makefile.programs - external/llvm.org/test-suite - Git at Google

 ##===- llvm-test/Makefile.programs -------------------------*- Makefile -*-===##
 #
 # This makefile contains all of the makefile machinery that is common to
 # building stuff in this directory.  This script can be used in two
 # different ways.  The main job of this is to take executables for the following
 # targets:
 #
 #   1. The native platform compiler
 #   2. LLVM Bytecode Compiler + LLI interpreter (if ENABLE_LLI is enabled)
 #   3. LLVM Bytecode Compiler + LLC static compiler
 #   4. LLVM Bytecode Compiler + C Backend + Native Sun Compiler
 #   5. LLVM Bytecode Compiler + LLI Just-In-Time Compiler
 #
 # Running them, and then diffing the output.  If there are any failures, they
 # are flagged.  The other mode is used in conjunction with the TEST=<testname>
 # argument on the make command line.  In this case, a Makefile.TEST.<testname>
 # makefile is used to run tests on the program (see below).
 #
 # Input to this makefile should be the PROGRAMS_TO_TEST variable, which contains
 # a list of programs that should be run.  The makefile can also optionally
 # specify a STDIN_FILENAME variable, which contains a filename that is piped
 # into the program as it is being executed.
 #
 #  FIXME: There should be a way to specify the command line for a program
 #
 ##===----------------------------------------------------------------------===##
 #
 #                            Running Custom Tests
 #
 # This makefile provides facilities for defining custom tests that are to be run
 # on all of the programs in the test suite.  In order to define one of these
 # tests, create a llvm-test/Makefile.TEST.<testname> file.  This file
 # should define a rule 'test.<testname>.%' which is run once for each program in
 # the suite (the % passed in is the program name).  For a simple example, see
 # Makefile.TEST.example.
 #
 ##===----------------------------------------------------------------------===##

 # Dependencies on header files need to be determined explicitly because
 # we do not automatically compute dependencies
 INCLUDES := $(ExtraHeaders) $(wildcard $(SourceDir)/*.h)

 include $(LEVEL)/Makefile.tests

 .PRECIOUS: Output/%.llvm Output/%.native Output/%.llc Output/%.llc.s
 .PRECIOUS: Output/%.cbe Output/%.cbe.c Output/%.llvm.bc
 .PRECIOUS: Output/%.linked.bc

 PROGDIR = $(PROJ_SRC_ROOT)

 #
 # Scripts in the this directory...
 #

 # TIMEPROG - The program used to get timing results for a program
 TIMEPROG := $(PROGDIR)/TimeProgram.sh

 TOLERANCEOPT :=
 ifdef FP_TOLERANCE
 TOLERANCEOPT += -r $(FP_TOLERANCE)
 endif
 ifdef FP_ABSTOLERANCE
 TOLERANCEOPT += -a $(FP_ABSTOLERANCE)
 endif

 # DIFFPROG - The program used to diff the output
 DIFFPROG := $(PROGDIR)/DiffOutput.sh "$(LLVMTOOLCURRENT)/fpcmp $(TOLERANCEOPT)"

 # RUNTIMELIMIT - The number of seconds we should wait before certain events
 # timeout.  This is overridable on the commandline or in tests makefiles.
 #
 ifndef RUNTIMELIMIT
   RUNTIMELIMIT := 500
 endif

 # RUNSAFELY - This program simply runs another program.  If the program works
 # correctly, this script has no effect, otherwise it will do things like print a
 # stack trace of a core dump.  It always returns "successful" so that tests will
 # continue to be run.
 ifndef GET_STABLE_NUMBERS
 RUNSAFELY := $(PROGDIR)/RunSafely.sh $(RUNTIMELIMIT)
 else
 RUNSAFELY := $(PROGDIR)/RunSafelyAndStable.sh $(RUNTIMELIMIT)
 endif

 ifndef STDIN_FILENAME
 STDIN_FILENAME := /dev/null
 endif

 #
 # Targets to build for the default target...
 #

 # We will be working in the Output directory...
 PREFIXED_PROGRAMS_TO_TEST := $(addprefix Output/,$(PROGRAMS_TO_TEST))

 # Completed bytecode for a program
 BYTECODE   := $(addsuffix .llvm.bc, $(PREFIXED_PROGRAMS_TO_TEST))

 LLCCODEGEN := $(addsuffix .llc.s,   $(PREFIXED_PROGRAMS_TO_TEST))
 LLCBETACODEGEN := $(addsuffix .llc-beta.s,   $(PREFIXED_PROGRAMS_TO_TEST))
 CBECODEGEN := $(addsuffix .cbe,     $(PREFIXED_PROGRAMS_TO_TEST))

 # Output produced by programs run
 GCCOUTPUT := $(addsuffix .ll,       $(addprefix Output/,$basename $(Source)))
 NATOUTPUT := $(addsuffix .out-nat,  $(PREFIXED_PROGRAMS_TO_TEST))
 LLIOUTPUT := $(addsuffix .out-lli,  $(PREFIXED_PROGRAMS_TO_TEST))
 JITOUTPUT := $(addsuffix .out-jit,  $(PREFIXED_PROGRAMS_TO_TEST))
 JITBETAOUTPUT := $(addsuffix .out-jit-beta,  $(PREFIXED_PROGRAMS_TO_TEST))
 LLCOUTPUT := $(addsuffix .out-llc,  $(PREFIXED_PROGRAMS_TO_TEST))
 LLCBETAOUTPUT := $(addsuffix .out-llc-beta,  $(PREFIXED_PROGRAMS_TO_TEST))
 CBEOUTPUT := $(addsuffix .out-cbe,  $(PREFIXED_PROGRAMS_TO_TEST))

 # Diffs of program runs vs the native program
 LLIDIFFS  := $(addsuffix .diff-lli, $(PREFIXED_PROGRAMS_TO_TEST))
 JITDIFFS  := $(addsuffix .diff-jit, $(PREFIXED_PROGRAMS_TO_TEST))
 JITBETADIFFS  := $(addsuffix .diff-jit-beta, $(PREFIXED_PROGRAMS_TO_TEST))
 LLCDIFFS  := $(addsuffix .diff-llc, $(PREFIXED_PROGRAMS_TO_TEST))
 LLCBETADIFFS  := $(addsuffix .diff-llc-beta, $(PREFIXED_PROGRAMS_TO_TEST))
 CBEDIFFS  := $(addsuffix .diff-cbe, $(PREFIXED_PROGRAMS_TO_TEST))

 # Profiles for the program.
 PROFOUTPUT := $(addsuffix .prof, $(PREFIXED_PROGRAMS_TO_TEST))
 PRINTPROFOUTPUT := $(addsuffix .printprof, $(PREFIXED_PROGRAMS_TO_TEST))

 # Build Program outputs:
 .PRECIOUS: Output/%.out-lli Output/%.out-jit Output/%.out-llc Output/%.out-llc-beta
 .PRECIOUS: Output/%.out-nat Output/%.out-cbe

 # Build diffs from the output...
 .PRECIOUS: Output/%.diff-lli Output/%.diff-jit
 .PRECIOUS: Output/%.diff-llc Output/%.diff-llc-beta Output/%.diff-cbe


 # Regardless of what other options are specified, build the program's bytecode
 # representation.
 all:: $(BYTECODE)
 profile:: $(PROFOUTPUT)
 print-profile:: $(PRINTPROFOUTPUT)


 ifdef RUN_GCC_ONLY
 DISABLE_DIFFS = 1
 all:: $(GCCOUTPUT)
 endif

 ifdef DISABLE_FOR_LLVM_PROGRAMS
   DISABLE_DIFFS := 1
 endif

 ifndef DISABLE_LLC
 all:: $(LLCCODEGEN)
 else
 DISABLE_LLC_DIFFS = 1
 endif

 ifndef DISABLE_CBE
 all:: $(CBECODEGEN)
 else
 DISABLE_CBE_DIFFS = 1
 endif

 ifndef DISABLE_DIFFS
 ifndef DISABLE_LLC_DIFFS
 all:: $(LLCDIFFS)
 ifdef ENABLE_LLCBETA
 all:: $(LLCBETADIFFS)
 endif
 endif#DISABLE_LLC_DIFFS

 ifndef DISABLE_CBE_DIFFS
 all:: $(CBEDIFFS)
 endif

 ifdef TARGET_HAS_JIT
 ifndef DISABLE_JIT
 all:: $(JITDIFFS)
 ifdef ENABLE_LLCBETA
 all:: $(JITBETADIFFS)
 endif
 endif#DISABLE_JIT
 endif#TARGET_HAS_JIT

 ifdef ENABLE_LLI
 all:: $(LLIDIFFS)
 endif
 endif#DISABLE_DIFFS

 ifeq ($(ARCH),PowerPC)
 LLCBETAOPTION := -enable-cc-opts
 endif
 ifeq ($(ARCH),Alpha)
 LLCBETAOPTION := -enable-alpha-intfpdiv -enable-alpha-ftoi
 #-enable-lsr-for-alpha
 endif
 ifeq ($(ARCH),x86)
 LLCBETAOPTION := -enable-x86-fastcc
 endif

 # Given a version of the entire program linked together into a single unit of
 # raw output from the C frontend, optimize it.
 $(PROGRAMS_TO_TEST:%=Output/%.linked.bc): \
 Output/%.linked.bc: Output/%.linked.rll $(LGCCAS)
 	-$(LGCCAS) $(STATS) $< -o $@

 $(PROGRAMS_TO_TEST:%=Output/%.llvm.stripped.bc): \
 Output/%.llvm.stripped.bc: Output/%.llvm.bc $(LOPT)
 	-$(LOPT) -mstrip $< -o $@ -f


 ifndef DISABLE_FOR_LLVM_PROGRAMS
 # Rule to produce final program bytecode file from linked, optimized, bytecode.
 # Link the program to the libraries it uses, then perform postlink
 # optimization...

 $(PROGRAMS_TO_TEST:%=Output/%.llvm.bc): \
 Output/%.llvm.bc: Output/%.linked.bc $(LGCCLDPROG)
 	-$(LGCCLD) $(STATS) $< $(EXTRA_LINKTIME_OPT_FLAGS) -lc $(LIBS) -lcrtend -o Output/$*.llvm
 ifneq ($(OPTPASSES),)
 	-$(LOPT) -q $(OPTPASSES) < $@ > $@.tmp
 	$(MV) -f $@.tmp $@
 endif

 $(PROGRAMS_TO_TEST:%=Output/%.llvm): \
 Output/%.llvm: Output/%.linked.bc $(LGCCLDPROG)
 	-$(LGCCLD) $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.llvm
 ifneq ($(OPTPASSES),)
 	-$(LOPT) -q $(OPTPASSES) < $@ > $@.tmp
 	$(MV) -f $@.tmp $@
 endif

 $(PROGRAMS_TO_TEST:%=Output/%.noopt-llvm.bc): \
 Output/%.noopt-llvm.bc: Output/%.linked.rbc $(LGCCLDPROG)
 	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.noopt-llvm

 $(PROGRAMS_TO_TEST:%=Output/%.noopt-llvm): \
 Output/%.noopt-llvm: Output/%.linked.rbc $(LGCCLDPROG)
 	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.noopt-llvm


 $(PROGRAMS_TO_TEST:%=Output/%.nogccldopt-llvm.bc): \
 Output/%.nogccldopt-llvm.bc: Output/%.linked.bc $(LGCCLDPROG)
 	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.nogccldopt-llvm

 $(PROGRAMS_TO_TEST:%=Output/%.nogccldopt-llvm): \
 Output/%.nogccldopt-llvm: Output/%.linked.rbc $(LGCCLDPROG)
 	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.nogccldopt-llvm

 endif   # ifndef DISABLE_FOR_LLVM_PROGRAMS

 # Targets to get the pass arguments that gccas and gccld are using...
 Output/gccas-pass-args: $(LGCCAS) Output/.dir
 	-$(LGCCAS) /dev/null -o /dev/null -debug-pass=Arguments > $@.1 2>&1
 	sed 's/Pass Arguments: //' < $@.1 > $@
 Output/gccld-pass-args: $(LGCCLDPROG) Output/.dir
 	$(LLVMAS) < /dev/null > Output/gccld.test.bc
 	$(LGCCLD) Output/gccld.test.bc -o Output/gccld.test-out -debug-pass=Arguments > $@.1 2>&1
 	sed 's/Pass Arguments: //' < $@.1 > $@

 # If the program requires exception handling support, enable (potentially
 # expensive) support for it.
 ifdef REQUIRES_EH_SUPPORT
 LLCFLAGS += -enable-correct-eh-support
 endif

 #
 # Rules to compile the program for the C Back End
 #
 $(PROGRAMS_TO_TEST:%=Output/%.cbe.c): \
 Output/%.cbe.c: Output/%.llvm.bc $(LLC)
 	-$(LLC) $(LLCFLAGS) -march=c $< -o $@ -f

 $(PROGRAMS_TO_TEST:%=Output/%.cbe): \
 Output/%.cbe: Output/%.cbe.c
 	-$(CC) $< $(LDFLAGS) $(CFLAGS) -fno-strict-aliasing -O2 -o $@

 #
 # Compile a linked program to machine code with LLC.
 #
 $(PROGRAMS_TO_TEST:%=Output/%.llc.s): \
 Output/%.llc.s: Output/%.llvm.bc $(LLC)
 	-$(LLC) $(LLCFLAGS) -f $< -o $@

 $(PROGRAMS_TO_TEST:%=Output/%.llc-beta.s): \
 Output/%.llc-beta.s: Output/%.llvm.bc $(LLC)
 	-$(LLC) $(LLCFLAGS) -f $(LLCBETAOPTION) $< -o $@


 ## Alternative command to run llc remotely on another machine:
 ## This is very useful when debugging:
 ##	-rsh psmith "cd `/bin/pwd`; llc $(LLCFLAGS) -f $< -o $@"

 # Assemble (and link) an LLVM-linked program using the system assembler...
 #
 $(PROGRAMS_TO_TEST:%=Output/%.llc): \
 Output/%.llc: Output/%.llc.s
 	-$(CC) $(CFLAGS) $< $(LLCLIBS) $(LDFLAGS) -o $@

 $(PROGRAMS_TO_TEST:%=Output/%.llc-beta): \
 Output/%.llc-beta: Output/%.llc-beta.s
 	-$(CC) $(CFLAGS) $< $(LLCLIBS) $(LDFLAGS) -o $@


 #
 # Rules to execute the program
 #

 # EXTRA_LLI_OPTS is used by the nightly tester to add arguments to invocations
 # of the JIT and LLI in order to get timing info and statistics.
 EXTRA_LLI_OPTS =

 LLI_OPTS = -force-interpreter=true $(EXTRA_LLI_OPTS)
 JIT_OPTS = -force-interpreter=false $(EXTRA_LLI_OPTS)


 # If the program requires exception handling support, enable (potentially
 # expensive) support for it.
 ifdef REQUIRES_EH_SUPPORT
 JIT_OPTS += -enable-correct-eh-support
 endif

 native: $(PROGRAMS_TO_TEST:%=Output/%.native)
 stripped-bytecode:: $(PROGRAMS_TO_TEST:%=Output/%.llvm.stripped.bc)

 ifndef PROGRAMS_HAVE_CUSTOM_RUN_RULES

 # Rules to build the test output...
 ifndef USE_PRECOMPILED_BYTECODE
 $(PROGRAMS_TO_TEST:%=Output/%.out-nat): \
 Output/%.out-nat: Output/%.native
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)
 endif

 $(PROGRAMS_TO_TEST:%=Output/%.out-lli): \
 Output/%.out-lli: Output/%.llvm.bc $(LLI)
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(LLI_OPTS) $< $(RUN_OPTIONS)

 $(PROGRAMS_TO_TEST:%=Output/%.out-jit): \
 Output/%.out-jit: Output/%.llvm.bc $(LLI)
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(JIT_OPTS) $< $(RUN_OPTIONS)
 ifdef PROGRAM_REQUIRED_TO_EXIT_OK
 	@if test \! -f $@.exitok; then echo "TEST (jit): $* FAILED!"; rm -f $@; fi
 endif

 $(PROGRAMS_TO_TEST:%=Output/%.out-jit-beta): \
 Output/%.out-jit-beta: Output/%.llvm.bc $(LLI)
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(LLCBETAOPTION) $(JIT_OPTS) $< $(RUN_OPTIONS)
 ifdef PROGRAM_REQUIRED_TO_EXIT_OK
 	@if test \! -f $@.exitok; then echo "TEST (jit-beta): $* FAILED!"; rm -f $@; fi
 endif

 $(PROGRAMS_TO_TEST:%=Output/%.out-llc): \
 Output/%.out-llc: Output/%.llc
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)

 $(PROGRAMS_TO_TEST:%=Output/%.out-llc-beta): \
 Output/%.out-llc-beta: Output/%.llc-beta
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)

 $(PROGRAMS_TO_TEST:%=Output/%.out-cbe): \
 Output/%.out-cbe: Output/%.cbe
 	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)

 # If a tolerance is set, pass it off to bugpoint
 ifdef FP_TOLERANCE
 BUGPOINT_OPTIONS += -rel-tolerance $(FP_TOLERANCE)
 endif
 ifdef FP_ABSTOLERANCE
 BUGPOINT_OPTIONS += -abs-tolerance $(FP_ABSTOLERANCE)
 endif

 # Specify stdin, reference output, and command line options for the program...
 BUGPOINT_OPTIONS += -input=$(STDIN_FILENAME) -output=Output/$*.out-nat
 BUGPOINT_OPTIONS += -timeout=$(RUNTIMELIMIT)
 BUGPOINT_OPTIONS += --tool-args $(LLCFLAGS)
 BUGPOINT_ARGS += --args -- $(RUN_OPTIONS)

 # Rules to bugpoint the GCCAS, GCCLD, LLC, or LLI commands...
 $(PROGRAMS_TO_TEST:%=Output/%.bugpoint-gccas): \
 Output/%.bugpoint-gccas: Output/%.noopt-llvm.bc $(LBUGPOINT) \
                          Output/gccas-pass-args Output/%.out-nat
 	$(LBUGPOINT) $< `cat Output/gccas-pass-args` $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

 $(PROGRAMS_TO_TEST:%=Output/%.bugpoint-gccld): \
 Output/%.bugpoint-gccld: Output/%.nogccldopt-llvm.bc $(LBUGPOINT) \
                          Output/gccld-pass-args Output/%.out-nat
 	$(LBUGPOINT) $< `cat Output/gccld-pass-args` $(OPTPASSES) $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

 $(PROGRAMS_TO_TEST:%=Output/%.bugpoint-llc): \
 Output/%.bugpoint-llc: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
 	$(LBUGPOINT) $< -run-llc $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

 $(PROGRAMS_TO_TEST:%=Output/%.bugpoint-llc-beta): \
 Output/%.bugpoint-llc-beta: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
 	$(LBUGPOINT) $< -run-llc $(BUGPOINT_OPTIONS) $(LLCBETAOPTION) $(BUGPOINT_ARGS)

 $(PROGRAMS_TO_TEST:%=Output/%.bugpoint-jit): \
 Output/%.bugpoint-jit: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
 	$(LBUGPOINT) $< -run-jit $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)


 LIBPROFILESO = $(LLVM_OBJ_ROOT)/Debug/lib/libprofile_rt.so

 $(PROGRAMS_TO_TEST:%=Output/%.prof): \
 Output/%.prof: Output/%.llvm-prof.bc Output/%.out-nat $(LIBPROFILESO)
 	@rm -f $@
 	-$(RUNSAFELY) $(STDIN_FILENAME) Output/$*.out-prof $(LLI) $(JIT_OPTS) \
             -fake-argv0 'Output/$*.llvm.bc' -load $(LIBPROFILESO) $< -llvmprof-output $@ $(RUN_OPTIONS)
 	@cmp -s Output/$*.out-prof Output/$*.out-nat || \
 		printf "***\n***\n*** WARNING: Output of profiled program (Output/$*.out-prof)\n*** doesn't match the output of the native program (Output/$*.out-nat)!\n***\n***\n";

 endif


 #
 # Rules to generate profiling information
 #
 $(PROGRAMS_TO_TEST:%=Output/%.llvm-prof.bc): \
 Output/%.llvm-prof.bc: Output/%.llvm.bc
 	$(LOPT) -insert-edge-profiling $< -o $@ -f

 $(PROGRAMS_TO_TEST:%=Output/%.printprof): \
 Output/%.printprof: Output/%.llvm.bc Output/%.prof $(LPROF)
 	$(LPROF) $< Output/$*.prof


 #
 # Rules to diff test output...
 #
 ifdef PROGRAM_IS_NONDETERMINISTIC
 # If the program is non-deterministic, just touch $@
 DIFFPROG = touch $@ \#
 endif

 $(PROGRAMS_TO_TEST:%=Output/%.diff-lli): \
 Output/%.diff-lli: Output/%.out-nat Output/%.out-lli
 	-$(DIFFPROG) lli $* $(HIDEDIFF)

 $(PROGRAMS_TO_TEST:%=Output/%.diff-jit): \
 Output/%.diff-jit: Output/%.out-nat Output/%.out-jit
 	-$(DIFFPROG) jit $* $(HIDEDIFF)

 $(PROGRAMS_TO_TEST:%=Output/%.diff-jit-beta): \
 Output/%.diff-jit-beta: Output/%.out-nat Output/%.out-jit-beta
 	-$(DIFFPROG) jit-beta $* $(HIDEDIFF)

 $(PROGRAMS_TO_TEST:%=Output/%.diff-llc): \
 Output/%.diff-llc: Output/%.out-nat Output/%.out-llc
 	-$(DIFFPROG) llc $* $(HIDEDIFF)

 $(PROGRAMS_TO_TEST:%=Output/%.diff-llc-beta): \
 Output/%.diff-llc-beta: Output/%.out-nat Output/%.out-llc-beta
 	-$(DIFFPROG) llc-beta $* $(HIDEDIFF)

 $(PROGRAMS_TO_TEST:%=Output/%.diff-cbe): \
 Output/%.diff-cbe: Output/%.out-nat Output/%.out-cbe
 	-$(DIFFPROG) cbe $* $(HIDEDIFF)

 ifndef DISABLE_DIFFS
 $(PROGRAMS_TO_TEST:%=Output/%.exe-lli): \
 Output/%.exe-lli: Output/%.diff-lli
 	-cp $< $@

 $(PROGRAMS_TO_TEST:%=Output/%.exe-jit): \
 Output/%.exe-jit: Output/%.diff-jit
 	-cp $< $@

 $(PROGRAMS_TO_TEST:%=Output/%.exe-jit-beta): \
 Output/%.exe-jit-beta: Output/%.diff-jit-beta
 	-cp $< $@

 $(PROGRAMS_TO_TEST:%=Output/%.exe-llc): \
 Output/%.exe-llc: Output/%.diff-llc
 	-cp $< $@

 $(PROGRAMS_TO_TEST:%=Output/%.exe-llc-beta): \
 Output/%.exe-llc-beta: Output/%.diff-llc-beta
 	-cp $< $@

 $(PROGRAMS_TO_TEST:%=Output/%.exe-cbe): \
 Output/%.exe-cbe: Output/%.diff-cbe
 	-cp $< $@

 # Pseudo target to build just the bytecode file.
 bytecode:: $(PROGRAMS_TO_TEST:%=Output/%.llvm.bc)

 endif

 # Rules to support the USE_PRECOMPILED_BYTECODE setting If set, submakefiles
 # will not know how to make output bytecode files for the programs in this
 # directory.  Instead, this makefile just copies them out of the bytecode
 # repository.
 ifdef USE_PRECOMPILED_BYTECODE

 # Calculate the directory we should copy the bytecode file into.  This is
 # relative to BYTECODE_REPOSITORY and the current directory this program is in.
 #
 CURDIR  := $(shell cd .; pwd)
 PROGDIR := $(shell cd $(LEVEL); pwd)
 SRCDIR  := $(BYTECODE_REPOSITORY)/$(subst $(PROGDIR),,$(CURDIR))

 # Because we don't have source code, we cannot build a native version of the
 # executable.  Copy over pregenerated reference output.
 $(PROGRAMS_TO_TEST:%=Output/%.out-nat): \
 Output/%.out-nat: $(SRCDIR)/%.reference_output Output/.dir
 	cp $< $@

 # To make a raw bytecode file up-to-date, just copy it over.
 $(PROGRAMS_TO_TEST:%=Output/%.linked.rll): \
 Output/%.linked.rll: $(SRCDIR)/%.linked.rll Output/.dir
 	cp $< $@

 $(PROGRAMS_TO_TEST:%=Output/%.LOC.txt): \
 Output/%.LOC.txt: $(SRCDIR)/%.LOC.txt Output/.dir
 	cp $< $@
 endif

 # Support for the TEST= option... when TEST= is specified on the command line,
 # the default target is the test target.  Here we dispatch to a specific set of
 # tests.
 #
 .PHONY: test-setup test-finish
 test-setup::
 test-finish::
 test:: test-setup $(PROGRAMS_TO_TEST:%=test.$(TEST).%) test-finish

 # AVAILABLE_TESTS - Compute the set of tests available for user help
 #
 TEST_FILES = $(wildcard $(PROGDIR)/TEST.*.Makefile) \
              $(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.*.Makefile)
 AVAILABLE_TESTS = $(patsubst TEST.%.Makefile,%,$(notdir $(TEST_FILES)))

 # If they just say 'make test' then we print out an error telling the user to
 # specify a TEST= option.
 $(PROGRAMS_TO_TEST:%=test..%): \
 test..%:
 	@echo
 	@echo "***************************************************************"
 	@echo "  ERROR: you cannot type '$(MAKE) test' directly."
 	@echo "  Instead, use '$(MAKE) TEST=X' where X is the name of a test."
 	@echo "  Tests available: $(AVAILABLE_TESTS)"
 	@echo "  Alternatively, just use '$(MAKE)' to run comparisons."
 	@echo "***************************************************************"
 	@echo
 	@exit 1

 # Include all makefiles which define tests... These makefiles must define
 # test.<testname>.%  given input from Output/%.llvm.bc
 #
 ifdef TEST
 TestMakefile := $(wildcard $(PROGDIR)/TEST.$(TEST).Makefile) \
                 $(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.$(TEST).Makefile)
 TestReport   := $(wildcard $(PROGDIR)/TEST.$(TEST).report) \
                 $(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.$(TEST).report)
 TestGnuPlot  := $(wildcard $(PROGDIR)/TEST.$(TEST).gnuplot) \
                 $(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.$(TEST).gnuplot)
 ifneq ($(strip $(TestMakefile)),)
 -include $(TestMakefile)
 else
 $(PROGRAMS_TO_TEST:%=test.$(TEST).%): \
 test.$(TEST).%:
 	@echo
 	@echo "***************************************************************"
 	@echo "  ERROR: Test '$(TEST)' is not a known test!"
 	@echo "  Tests Available: $(AVAILABLE_TESTS)"
 	@echo "  Test Program: $*"
 	@echo "  Test Makefile: $(TestMakefile)"
 	@echo "  Test Report: $(TestReport)"
 	@echo "***************************************************************"
 	@echo
 	@exit 1
 endif
 endif

 #
 # Rules for building a report from 'make report TEST=<x>'
 #
 GENERATEREPORT := $(PROJ_SRC_ROOT)/GenerateReport.pl

 report.$(TEST).raw.out: $(REPORT_DEPENDENCIES) $(TestMakefile)
 	$(MAKE) -j1 TEST=$(TEST) 2>&1 | tee $@

 ifneq ($(TestReport),)
 report.$(TEST).txt: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
 	$(GENERATEREPORT) $(TestReport) < $< > $@

 report.$(TEST).html: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
 	$(GENERATEREPORT) -html $(TestReport) < $< > $@

 report.$(TEST).tex: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
 	$(GENERATEREPORT) -latex $(TestReport) < $< > $@

 report.$(TEST).csv: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
 	$(GENERATEREPORT) -csv $(TestReport) < $< > $@

 report.graphs: report.$(TEST).raw.out $(TestReport) $(TestGnuPlot) $(GENERATEREPORT)
 	$(GENERATEREPORT) -graphs $(TestReport) < $<
 	gnuplot $(TestGnuPlot)

 report: report.$(TEST).txt
 	@cat $<

 report.html: report.$(TEST).html

 report.csv: report.$(TEST).csv

 report.tex: report.$(TEST).tex
 	@cat $<
 endif

 clean::
 	rm -f report.*.raw.out report.*.txt report.*.html report.*.tex report.*.csv
	##===- llvm-test/Makefile.programs -------------------------- Makefile --===##
	#
	# This makefile contains all of the makefile machinery that is common to
	# building stuff in this directory. This script can be used in two
	# different ways. The main job of this is to take executables for the following
	# targets:
	#
	# 1. The native platform compiler
	# 2. LLVM Bytecode Compiler + LLI interpreter (if ENABLE_LLI is enabled)
	# 3. LLVM Bytecode Compiler + LLC static compiler
	# 4. LLVM Bytecode Compiler + C Backend + Native Sun Compiler
	# 5. LLVM Bytecode Compiler + LLI Just-In-Time Compiler
	#
	# Running them, and then diffing the output. If there are any failures, they
	# are flagged. The other mode is used in conjunction with the TEST=<testname>
	# argument on the make command line. In this case, a Makefile.TEST.<testname>
	# makefile is used to run tests on the program (see below).
	#
	# Input to this makefile should be the PROGRAMS_TO_TEST variable, which contains
	# a list of programs that should be run. The makefile can also optionally
	# specify a STDIN_FILENAME variable, which contains a filename that is piped
	# into the program as it is being executed.
	#
	# FIXME: There should be a way to specify the command line for a program
	#
	##===----------------------------------------------------------------------===##
	#
	# Running Custom Tests
	#
	# This makefile provides facilities for defining custom tests that are to be run
	# on all of the programs in the test suite. In order to define one of these
	# tests, create a llvm-test/Makefile.TEST.<testname> file. This file
	# should define a rule 'test.<testname>.%' which is run once for each program in
	# the suite (the % passed in is the program name). For a simple example, see
	# Makefile.TEST.example.
	#
	##===----------------------------------------------------------------------===##

	# Dependencies on header files need to be determined explicitly because
	# we do not automatically compute dependencies
	INCLUDES := $(ExtraHeaders) $(wildcard $(SourceDir)/*.h)

	include $(LEVEL)/Makefile.tests

	.PRECIOUS: Output/%.llvm Output/%.native Output/%.llc Output/%.llc.s
	.PRECIOUS: Output/%.cbe Output/%.cbe.c Output/%.llvm.bc
	.PRECIOUS: Output/%.linked.bc

	PROGDIR = $(PROJ_SRC_ROOT)

	#
	# Scripts in the this directory...
	#

	# TIMEPROG - The program used to get timing results for a program
	TIMEPROG := $(PROGDIR)/TimeProgram.sh

	TOLERANCEOPT :=
	ifdef FP_TOLERANCE
	TOLERANCEOPT += -r $(FP_TOLERANCE)
	endif
	ifdef FP_ABSTOLERANCE
	TOLERANCEOPT += -a $(FP_ABSTOLERANCE)
	endif

	# DIFFPROG - The program used to diff the output
	DIFFPROG := $(PROGDIR)/DiffOutput.sh "$(LLVMTOOLCURRENT)/fpcmp $(TOLERANCEOPT)"

	# RUNTIMELIMIT - The number of seconds we should wait before certain events
	# timeout. This is overridable on the commandline or in tests makefiles.
	#
	ifndef RUNTIMELIMIT
	RUNTIMELIMIT := 500
	endif

	# RUNSAFELY - This program simply runs another program. If the program works
	# correctly, this script has no effect, otherwise it will do things like print a
	# stack trace of a core dump. It always returns "successful" so that tests will
	# continue to be run.
	ifndef GET_STABLE_NUMBERS
	RUNSAFELY := $(PROGDIR)/RunSafely.sh $(RUNTIMELIMIT)
	else
	RUNSAFELY := $(PROGDIR)/RunSafelyAndStable.sh $(RUNTIMELIMIT)
	endif

	ifndef STDIN_FILENAME
	STDIN_FILENAME := /dev/null
	endif

	#
	# Targets to build for the default target...
	#

	# We will be working in the Output directory...
	PREFIXED_PROGRAMS_TO_TEST := $(addprefix Output/,$(PROGRAMS_TO_TEST))

	# Completed bytecode for a program
	BYTECODE := $(addsuffix .llvm.bc, $(PREFIXED_PROGRAMS_TO_TEST))

	LLCCODEGEN := $(addsuffix .llc.s, $(PREFIXED_PROGRAMS_TO_TEST))
	LLCBETACODEGEN := $(addsuffix .llc-beta.s, $(PREFIXED_PROGRAMS_TO_TEST))
	CBECODEGEN := $(addsuffix .cbe, $(PREFIXED_PROGRAMS_TO_TEST))

	# Output produced by programs run
	GCCOUTPUT := $(addsuffix .ll, $(addprefix Output/,$basename $(Source)))
	NATOUTPUT := $(addsuffix .out-nat, $(PREFIXED_PROGRAMS_TO_TEST))
	LLIOUTPUT := $(addsuffix .out-lli, $(PREFIXED_PROGRAMS_TO_TEST))
	JITOUTPUT := $(addsuffix .out-jit, $(PREFIXED_PROGRAMS_TO_TEST))
	JITBETAOUTPUT := $(addsuffix .out-jit-beta, $(PREFIXED_PROGRAMS_TO_TEST))
	LLCOUTPUT := $(addsuffix .out-llc, $(PREFIXED_PROGRAMS_TO_TEST))
	LLCBETAOUTPUT := $(addsuffix .out-llc-beta, $(PREFIXED_PROGRAMS_TO_TEST))
	CBEOUTPUT := $(addsuffix .out-cbe, $(PREFIXED_PROGRAMS_TO_TEST))

	# Diffs of program runs vs the native program
	LLIDIFFS := $(addsuffix .diff-lli, $(PREFIXED_PROGRAMS_TO_TEST))
	JITDIFFS := $(addsuffix .diff-jit, $(PREFIXED_PROGRAMS_TO_TEST))
	JITBETADIFFS := $(addsuffix .diff-jit-beta, $(PREFIXED_PROGRAMS_TO_TEST))
	LLCDIFFS := $(addsuffix .diff-llc, $(PREFIXED_PROGRAMS_TO_TEST))
	LLCBETADIFFS := $(addsuffix .diff-llc-beta, $(PREFIXED_PROGRAMS_TO_TEST))
	CBEDIFFS := $(addsuffix .diff-cbe, $(PREFIXED_PROGRAMS_TO_TEST))

	# Profiles for the program.
	PROFOUTPUT := $(addsuffix .prof, $(PREFIXED_PROGRAMS_TO_TEST))
	PRINTPROFOUTPUT := $(addsuffix .printprof, $(PREFIXED_PROGRAMS_TO_TEST))

	# Build Program outputs:
	.PRECIOUS: Output/%.out-lli Output/%.out-jit Output/%.out-llc Output/%.out-llc-beta
	.PRECIOUS: Output/%.out-nat Output/%.out-cbe

	# Build diffs from the output...
	.PRECIOUS: Output/%.diff-lli Output/%.diff-jit
	.PRECIOUS: Output/%.diff-llc Output/%.diff-llc-beta Output/%.diff-cbe


	# Regardless of what other options are specified, build the program's bytecode
	# representation.
	all:: $(BYTECODE)
	profile:: $(PROFOUTPUT)
	print-profile:: $(PRINTPROFOUTPUT)


	ifdef RUN_GCC_ONLY
	DISABLE_DIFFS = 1
	all:: $(GCCOUTPUT)
	endif

	ifdef DISABLE_FOR_LLVM_PROGRAMS
	DISABLE_DIFFS := 1
	endif

	ifndef DISABLE_LLC
	all:: $(LLCCODEGEN)
	else
	DISABLE_LLC_DIFFS = 1
	endif

	ifndef DISABLE_CBE
	all:: $(CBECODEGEN)
	else
	DISABLE_CBE_DIFFS = 1
	endif

	ifndef DISABLE_DIFFS
	ifndef DISABLE_LLC_DIFFS
	all:: $(LLCDIFFS)
	ifdef ENABLE_LLCBETA
	all:: $(LLCBETADIFFS)
	endif
	endif#DISABLE_LLC_DIFFS

	ifndef DISABLE_CBE_DIFFS
	all:: $(CBEDIFFS)
	endif

	ifdef TARGET_HAS_JIT
	ifndef DISABLE_JIT
	all:: $(JITDIFFS)
	ifdef ENABLE_LLCBETA
	all:: $(JITBETADIFFS)
	endif
	endif#DISABLE_JIT
	endif#TARGET_HAS_JIT

	ifdef ENABLE_LLI
	all:: $(LLIDIFFS)
	endif
	endif#DISABLE_DIFFS

	ifeq ($(ARCH),PowerPC)
	LLCBETAOPTION := -enable-cc-opts
	endif
	ifeq ($(ARCH),Alpha)
	LLCBETAOPTION := -enable-alpha-intfpdiv -enable-alpha-ftoi
	#-enable-lsr-for-alpha
	endif
	ifeq ($(ARCH),x86)
	LLCBETAOPTION := -enable-x86-fastcc
	endif

	# Given a version of the entire program linked together into a single unit of
	# raw output from the C frontend, optimize it.
	$(PROGRAMS_TO_TEST:%=Output/%.linked.bc): \
	Output/%.linked.bc: Output/%.linked.rll $(LGCCAS)
	-$(LGCCAS) $(STATS) $< -o $@

	$(PROGRAMS_TO_TEST:%=Output/%.llvm.stripped.bc): \
	Output/%.llvm.stripped.bc: Output/%.llvm.bc $(LOPT)
	-$(LOPT) -mstrip $< -o $@ -f


	ifndef DISABLE_FOR_LLVM_PROGRAMS
	# Rule to produce final program bytecode file from linked, optimized, bytecode.
	# Link the program to the libraries it uses, then perform postlink
	# optimization...

	$(PROGRAMS_TO_TEST:%=Output/%.llvm.bc): \
	Output/%.llvm.bc: Output/%.linked.bc $(LGCCLDPROG)
	-$(LGCCLD) $(STATS) $< $(EXTRA_LINKTIME_OPT_FLAGS) -lc $(LIBS) -lcrtend -o Output/$*.llvm
	ifneq ($(OPTPASSES),)
	-$(LOPT) -q $(OPTPASSES) < $@ > $@.tmp
	$(MV) -f $@.tmp $@
	endif

	$(PROGRAMS_TO_TEST:%=Output/%.llvm): \
	Output/%.llvm: Output/%.linked.bc $(LGCCLDPROG)
	-$(LGCCLD) $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.llvm
	ifneq ($(OPTPASSES),)
	-$(LOPT) -q $(OPTPASSES) < $@ > $@.tmp
	$(MV) -f $@.tmp $@
	endif

	$(PROGRAMS_TO_TEST:%=Output/%.noopt-llvm.bc): \
	Output/%.noopt-llvm.bc: Output/%.linked.rbc $(LGCCLDPROG)
	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.noopt-llvm

	$(PROGRAMS_TO_TEST:%=Output/%.noopt-llvm): \
	Output/%.noopt-llvm: Output/%.linked.rbc $(LGCCLDPROG)
	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.noopt-llvm


	$(PROGRAMS_TO_TEST:%=Output/%.nogccldopt-llvm.bc): \
	Output/%.nogccldopt-llvm.bc: Output/%.linked.bc $(LGCCLDPROG)
	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.nogccldopt-llvm

	$(PROGRAMS_TO_TEST:%=Output/%.nogccldopt-llvm): \
	Output/%.nogccldopt-llvm: Output/%.linked.rbc $(LGCCLDPROG)
	-$(LGCCLD) -disable-opt $(STATS) $< -lc $(LIBS) -lcrtend -o Output/$*.nogccldopt-llvm

	endif # ifndef DISABLE_FOR_LLVM_PROGRAMS

	# Targets to get the pass arguments that gccas and gccld are using...
	Output/gccas-pass-args: $(LGCCAS) Output/.dir
	-$(LGCCAS) /dev/null -o /dev/null -debug-pass=Arguments > $@.1 2>&1
	sed 's/Pass Arguments: //' < $@.1 > $@
	Output/gccld-pass-args: $(LGCCLDPROG) Output/.dir
	$(LLVMAS) < /dev/null > Output/gccld.test.bc
	$(LGCCLD) Output/gccld.test.bc -o Output/gccld.test-out -debug-pass=Arguments > $@.1 2>&1
	sed 's/Pass Arguments: //' < $@.1 > $@

	# If the program requires exception handling support, enable (potentially
	# expensive) support for it.
	ifdef REQUIRES_EH_SUPPORT
	LLCFLAGS += -enable-correct-eh-support
	endif

	#
	# Rules to compile the program for the C Back End
	#
	$(PROGRAMS_TO_TEST:%=Output/%.cbe.c): \
	Output/%.cbe.c: Output/%.llvm.bc $(LLC)
	-$(LLC) $(LLCFLAGS) -march=c $< -o $@ -f

	$(PROGRAMS_TO_TEST:%=Output/%.cbe): \
	Output/%.cbe: Output/%.cbe.c
	-$(CC) $< $(LDFLAGS) $(CFLAGS) -fno-strict-aliasing -O2 -o $@

	#
	# Compile a linked program to machine code with LLC.
	#
	$(PROGRAMS_TO_TEST:%=Output/%.llc.s): \
	Output/%.llc.s: Output/%.llvm.bc $(LLC)
	-$(LLC) $(LLCFLAGS) -f $< -o $@

	$(PROGRAMS_TO_TEST:%=Output/%.llc-beta.s): \
	Output/%.llc-beta.s: Output/%.llvm.bc $(LLC)
	-$(LLC) $(LLCFLAGS) -f $(LLCBETAOPTION) $< -o $@


	## Alternative command to run llc remotely on another machine:
	## This is very useful when debugging:
	## -rsh psmith "cd `/bin/pwd`; llc $(LLCFLAGS) -f $< -o $@"

	# Assemble (and link) an LLVM-linked program using the system assembler...
	#
	$(PROGRAMS_TO_TEST:%=Output/%.llc): \
	Output/%.llc: Output/%.llc.s
	-$(CC) $(CFLAGS) $< $(LLCLIBS) $(LDFLAGS) -o $@

	$(PROGRAMS_TO_TEST:%=Output/%.llc-beta): \
	Output/%.llc-beta: Output/%.llc-beta.s
	-$(CC) $(CFLAGS) $< $(LLCLIBS) $(LDFLAGS) -o $@


	#
	# Rules to execute the program
	#

	# EXTRA_LLI_OPTS is used by the nightly tester to add arguments to invocations
	# of the JIT and LLI in order to get timing info and statistics.
	EXTRA_LLI_OPTS =

	LLI_OPTS = -force-interpreter=true $(EXTRA_LLI_OPTS)
	JIT_OPTS = -force-interpreter=false $(EXTRA_LLI_OPTS)


	# If the program requires exception handling support, enable (potentially
	# expensive) support for it.
	ifdef REQUIRES_EH_SUPPORT
	JIT_OPTS += -enable-correct-eh-support
	endif

	native: $(PROGRAMS_TO_TEST:%=Output/%.native)
	stripped-bytecode:: $(PROGRAMS_TO_TEST:%=Output/%.llvm.stripped.bc)

	ifndef PROGRAMS_HAVE_CUSTOM_RUN_RULES

	# Rules to build the test output...
	ifndef USE_PRECOMPILED_BYTECODE
	$(PROGRAMS_TO_TEST:%=Output/%.out-nat): \
	Output/%.out-nat: Output/%.native
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)
	endif

	$(PROGRAMS_TO_TEST:%=Output/%.out-lli): \
	Output/%.out-lli: Output/%.llvm.bc $(LLI)
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(LLI_OPTS) $< $(RUN_OPTIONS)

	$(PROGRAMS_TO_TEST:%=Output/%.out-jit): \
	Output/%.out-jit: Output/%.llvm.bc $(LLI)
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(JIT_OPTS) $< $(RUN_OPTIONS)
	ifdef PROGRAM_REQUIRED_TO_EXIT_OK
	@if test \! -f $@.exitok; then echo "TEST (jit): $* FAILED!"; rm -f $@; fi
	endif

	$(PROGRAMS_TO_TEST:%=Output/%.out-jit-beta): \
	Output/%.out-jit-beta: Output/%.llvm.bc $(LLI)
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(LLCBETAOPTION) $(JIT_OPTS) $< $(RUN_OPTIONS)
	ifdef PROGRAM_REQUIRED_TO_EXIT_OK
	@if test \! -f $@.exitok; then echo "TEST (jit-beta): $* FAILED!"; rm -f $@; fi
	endif

	$(PROGRAMS_TO_TEST:%=Output/%.out-llc): \
	Output/%.out-llc: Output/%.llc
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)

	$(PROGRAMS_TO_TEST:%=Output/%.out-llc-beta): \
	Output/%.out-llc-beta: Output/%.llc-beta
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)

	$(PROGRAMS_TO_TEST:%=Output/%.out-cbe): \
	Output/%.out-cbe: Output/%.cbe
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)

	# If a tolerance is set, pass it off to bugpoint
	ifdef FP_TOLERANCE
	BUGPOINT_OPTIONS += -rel-tolerance $(FP_TOLERANCE)
	endif
	ifdef FP_ABSTOLERANCE
	BUGPOINT_OPTIONS += -abs-tolerance $(FP_ABSTOLERANCE)
	endif

	# Specify stdin, reference output, and command line options for the program...
	BUGPOINT_OPTIONS += -input=$(STDIN_FILENAME) -output=Output/$*.out-nat
	BUGPOINT_OPTIONS += -timeout=$(RUNTIMELIMIT)
	BUGPOINT_OPTIONS += --tool-args $(LLCFLAGS)
	BUGPOINT_ARGS += --args -- $(RUN_OPTIONS)

	# Rules to bugpoint the GCCAS, GCCLD, LLC, or LLI commands...
	$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-gccas): \
	Output/%.bugpoint-gccas: Output/%.noopt-llvm.bc $(LBUGPOINT) \
	Output/gccas-pass-args Output/%.out-nat
	$(LBUGPOINT) $< `cat Output/gccas-pass-args` $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

	$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-gccld): \
	Output/%.bugpoint-gccld: Output/%.nogccldopt-llvm.bc $(LBUGPOINT) \
	Output/gccld-pass-args Output/%.out-nat
	$(LBUGPOINT) $< `cat Output/gccld-pass-args` $(OPTPASSES) $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

	$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-llc): \
	Output/%.bugpoint-llc: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
	$(LBUGPOINT) $< -run-llc $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

	$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-llc-beta): \
	Output/%.bugpoint-llc-beta: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
	$(LBUGPOINT) $< -run-llc $(BUGPOINT_OPTIONS) $(LLCBETAOPTION) $(BUGPOINT_ARGS)

	$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-jit): \
	Output/%.bugpoint-jit: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
	$(LBUGPOINT) $< -run-jit $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)


	LIBPROFILESO = $(LLVM_OBJ_ROOT)/Debug/lib/libprofile_rt.so

	$(PROGRAMS_TO_TEST:%=Output/%.prof): \
	Output/%.prof: Output/%.llvm-prof.bc Output/%.out-nat $(LIBPROFILESO)
	@rm -f $@
	-$(RUNSAFELY) $(STDIN_FILENAME) Output/$*.out-prof $(LLI) $(JIT_OPTS) \
	-fake-argv0 'Output/$*.llvm.bc' -load $(LIBPROFILESO) $< -llvmprof-output $@ $(RUN_OPTIONS)
	@cmp -s Output/$.out-prof Output/$.out-nat \|\| \
	printf "*\n\n** WARNING: Output of profiled program (Output/$.out-prof)\n** doesn't match the output of the native program (Output/$.out-nat)!\n\n*\n";

	endif


	#
	# Rules to generate profiling information
	#
	$(PROGRAMS_TO_TEST:%=Output/%.llvm-prof.bc): \
	Output/%.llvm-prof.bc: Output/%.llvm.bc
	$(LOPT) -insert-edge-profiling $< -o $@ -f

	$(PROGRAMS_TO_TEST:%=Output/%.printprof): \
	Output/%.printprof: Output/%.llvm.bc Output/%.prof $(LPROF)
	$(LPROF) $< Output/$*.prof


	#
	# Rules to diff test output...
	#
	ifdef PROGRAM_IS_NONDETERMINISTIC
	# If the program is non-deterministic, just touch $@
	DIFFPROG = touch $@ \#
	endif

	$(PROGRAMS_TO_TEST:%=Output/%.diff-lli): \
	Output/%.diff-lli: Output/%.out-nat Output/%.out-lli
	-$(DIFFPROG) lli $* $(HIDEDIFF)

	$(PROGRAMS_TO_TEST:%=Output/%.diff-jit): \
	Output/%.diff-jit: Output/%.out-nat Output/%.out-jit
	-$(DIFFPROG) jit $* $(HIDEDIFF)

	$(PROGRAMS_TO_TEST:%=Output/%.diff-jit-beta): \
	Output/%.diff-jit-beta: Output/%.out-nat Output/%.out-jit-beta
	-$(DIFFPROG) jit-beta $* $(HIDEDIFF)

	$(PROGRAMS_TO_TEST:%=Output/%.diff-llc): \
	Output/%.diff-llc: Output/%.out-nat Output/%.out-llc
	-$(DIFFPROG) llc $* $(HIDEDIFF)

	$(PROGRAMS_TO_TEST:%=Output/%.diff-llc-beta): \
	Output/%.diff-llc-beta: Output/%.out-nat Output/%.out-llc-beta
	-$(DIFFPROG) llc-beta $* $(HIDEDIFF)

	$(PROGRAMS_TO_TEST:%=Output/%.diff-cbe): \
	Output/%.diff-cbe: Output/%.out-nat Output/%.out-cbe
	-$(DIFFPROG) cbe $* $(HIDEDIFF)

	ifndef DISABLE_DIFFS
	$(PROGRAMS_TO_TEST:%=Output/%.exe-lli): \
	Output/%.exe-lli: Output/%.diff-lli
	-cp $< $@

	$(PROGRAMS_TO_TEST:%=Output/%.exe-jit): \
	Output/%.exe-jit: Output/%.diff-jit
	-cp $< $@

	$(PROGRAMS_TO_TEST:%=Output/%.exe-jit-beta): \
	Output/%.exe-jit-beta: Output/%.diff-jit-beta
	-cp $< $@

	$(PROGRAMS_TO_TEST:%=Output/%.exe-llc): \
	Output/%.exe-llc: Output/%.diff-llc
	-cp $< $@

	$(PROGRAMS_TO_TEST:%=Output/%.exe-llc-beta): \
	Output/%.exe-llc-beta: Output/%.diff-llc-beta
	-cp $< $@

	$(PROGRAMS_TO_TEST:%=Output/%.exe-cbe): \
	Output/%.exe-cbe: Output/%.diff-cbe
	-cp $< $@

	# Pseudo target to build just the bytecode file.
	bytecode:: $(PROGRAMS_TO_TEST:%=Output/%.llvm.bc)

	endif

	# Rules to support the USE_PRECOMPILED_BYTECODE setting If set, submakefiles
	# will not know how to make output bytecode files for the programs in this
	# directory. Instead, this makefile just copies them out of the bytecode
	# repository.
	ifdef USE_PRECOMPILED_BYTECODE

	# Calculate the directory we should copy the bytecode file into. This is
	# relative to BYTECODE_REPOSITORY and the current directory this program is in.
	#
	CURDIR := $(shell cd .; pwd)
	PROGDIR := $(shell cd $(LEVEL); pwd)
	SRCDIR := $(BYTECODE_REPOSITORY)/$(subst $(PROGDIR),,$(CURDIR))

	# Because we don't have source code, we cannot build a native version of the
	# executable. Copy over pregenerated reference output.
	$(PROGRAMS_TO_TEST:%=Output/%.out-nat): \
	Output/%.out-nat: $(SRCDIR)/%.reference_output Output/.dir
	cp $< $@

	# To make a raw bytecode file up-to-date, just copy it over.
	$(PROGRAMS_TO_TEST:%=Output/%.linked.rll): \
	Output/%.linked.rll: $(SRCDIR)/%.linked.rll Output/.dir
	cp $< $@

	$(PROGRAMS_TO_TEST:%=Output/%.LOC.txt): \
	Output/%.LOC.txt: $(SRCDIR)/%.LOC.txt Output/.dir
	cp $< $@
	endif

	# Support for the TEST= option... when TEST= is specified on the command line,
	# the default target is the test target. Here we dispatch to a specific set of
	# tests.
	#
	.PHONY: test-setup test-finish
	test-setup::
	test-finish::
	test:: test-setup $(PROGRAMS_TO_TEST:%=test.$(TEST).%) test-finish

	# AVAILABLE_TESTS - Compute the set of tests available for user help
	#
	TEST_FILES = $(wildcard $(PROGDIR)/TEST.*.Makefile) \
	$(wildcard $(LLVM_SRC_ROOT)/projects//test/TEST..Makefile)
	AVAILABLE_TESTS = $(patsubst TEST.%.Makefile,%,$(notdir $(TEST_FILES)))

	# If they just say 'make test' then we print out an error telling the user to
	# specify a TEST= option.
	$(PROGRAMS_TO_TEST:%=test..%): \
	test..%:
	@echo
	@echo "***************************************************************"
	@echo " ERROR: you cannot type '$(MAKE) test' directly."
	@echo " Instead, use '$(MAKE) TEST=X' where X is the name of a test."
	@echo " Tests available: $(AVAILABLE_TESTS)"
	@echo " Alternatively, just use '$(MAKE)' to run comparisons."
	@echo "***************************************************************"
	@echo
	@exit 1

	# Include all makefiles which define tests... These makefiles must define
	# test.<testname>.% given input from Output/%.llvm.bc
	#
	ifdef TEST
	TestMakefile := $(wildcard $(PROGDIR)/TEST.$(TEST).Makefile) \
	$(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.$(TEST).Makefile)
	TestReport := $(wildcard $(PROGDIR)/TEST.$(TEST).report) \
	$(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.$(TEST).report)
	TestGnuPlot := $(wildcard $(PROGDIR)/TEST.$(TEST).gnuplot) \
	$(wildcard $(LLVM_SRC_ROOT)/projects/*/test/TEST.$(TEST).gnuplot)
	ifneq ($(strip $(TestMakefile)),)
	-include $(TestMakefile)
	else
	$(PROGRAMS_TO_TEST:%=test.$(TEST).%): \
	test.$(TEST).%:
	@echo
	@echo "***************************************************************"
	@echo " ERROR: Test '$(TEST)' is not a known test!"
	@echo " Tests Available: $(AVAILABLE_TESTS)"
	@echo " Test Program: $*"
	@echo " Test Makefile: $(TestMakefile)"
	@echo " Test Report: $(TestReport)"
	@echo "***************************************************************"
	@echo
	@exit 1
	endif
	endif

	#
	# Rules for building a report from 'make report TEST=<x>'
	#
	GENERATEREPORT := $(PROJ_SRC_ROOT)/GenerateReport.pl

	report.$(TEST).raw.out: $(REPORT_DEPENDENCIES) $(TestMakefile)
	$(MAKE) -j1 TEST=$(TEST) 2>&1 \| tee $@

	ifneq ($(TestReport),)
	report.$(TEST).txt: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
	$(GENERATEREPORT) $(TestReport) < $< > $@

	report.$(TEST).html: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
	$(GENERATEREPORT) -html $(TestReport) < $< > $@

	report.$(TEST).tex: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
	$(GENERATEREPORT) -latex $(TestReport) < $< > $@

	report.$(TEST).csv: report.$(TEST).raw.out $(TestReport) $(GENERATEREPORT)
	$(GENERATEREPORT) -csv $(TestReport) < $< > $@

	report.graphs: report.$(TEST).raw.out $(TestReport) $(TestGnuPlot) $(GENERATEREPORT)
	$(GENERATEREPORT) -graphs $(TestReport) < $<
	gnuplot $(TestGnuPlot)

	report: report.$(TEST).txt
	@cat $<

	report.html: report.$(TEST).html

	report.csv: report.$(TEST).csv

	report.tex: report.$(TEST).tex
	@cat $<
	endif

	clean::
	rm -f report..raw.out report..txt report..html report..tex report.*.csv