##===- 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/TEST.<testname>.Makefile 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 Output/%.linked.bc

# If we're using the llvm-gcc3 compiler then we need to also link with the
# llvm c runtime library, othwerwise we don't
ifneq ($(LLVMGCC_MAJVERS),4)
LIBS += -lcrtend
endif

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.
ifdef PROGRAM_REQUIRED_TO_EXIT_OK
EXIT_OK := 1
else
EXIT_OK := 0
endif
ifdef GET_STABLE_NUMBERS
RUNSAFELY := $(PROGDIR)/RunSafelyAndStable.sh $(RUNTIMELIMIT) $(EXIT_OK)
else
ifdef REMOTE_HOST
ifdef REMOTE_USER
RUNSAFELY := $(PROGDIR)/RunSafely.sh -r $(REMOTE_HOST) -l $(REMOTE_USER) $(RUNTIMELIMIT) $(EXIT_OK)
else
RUNSAFELY := $(PROGDIR)/RunSafely.sh -r $(REMOTE_HOST) $(RUNTIMELIMIT) $(EXIT_OK)
endif
else
RUNSAFELY := $(PROGDIR)/RunSafely.sh $(RUNTIMELIMIT) $(EXIT_OK)
endif
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)

# JIT remote tests are not supported yet.
ifdef REMOTE_HOST
  DISABLE_JIT := 1
endif

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-sinking
#-machine-licm
#--enable-tail-merge
#--enable-ppc-preinc
#-regalloc=local -fast
endif
ifeq ($(ARCH),Alpha)
LLCBETAOPTION := -sched=list-td 
# -enable-alpha-FTOI -enable-alpha-intfpdiv
endif
ifeq ($(ARCH),IA64)
LLCBETAOPTION := -sched=simple 
endif
ifeq ($(ARCH),x86)
LLCBETAOPTION := -enable-sinking
#-machine-licm
#-new-coalescer-heuristic=true
#-tailcallopt
#-regalloc=local -fast
#-disable-rematerialization
#-disable-fp-elim
#-regalloc=bigblock -fast
endif
ifeq ($(ARCH),Sparc)
LLCBETAOPTION := -enable-sparc-v9-insts
endif
ifeq ($(ARCH),ARM)
LLCBETAOPTION := -new-coalescer-heuristic=true
#-disable-rematerialization
#-march=thumb
endif
ifeq ($(ARCH),THUMB)
LLCBETAOPTION := --enable-thumb-reg-scavenging
endif

print-llcbeta-option:
	@echo $(LLCBETAOPTION)

# Given an unoptimized bytecode file that is a simple linkage of all
# the program's bytecode files, optimize the program using the
# standard compilation optimizations.
$(PROGRAMS_TO_TEST:%=Output/%.linked.bc): \
Output/%.linked.bc: Output/%.linked.rbc $(LOPT)
	-$(LOPT) -std-compile-opts -time-passes -info-output-file=$(CURDIR)/$@.info $(STATS) $(EXTRA_LOPT_OPTIONS) $< -o $@ -f

$(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 $(LLVM_LDDPROG)
	-$(LLVMLD) $(STATS) $< $(EXTRA_LINKTIME_OPT_FLAGS) $(LLVMLD_FLAGS) -lc $(LIBS) -o Output/$*.llvm
ifneq ($(OPTPASSES),)
	-$(LOPT) -q $(OPTPASSES) $@ -o $@.tmp -f
	$(MV) -f $@.tmp $@
endif

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

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

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


$(PROGRAMS_TO_TEST:%=Output/%.nollvm-ldopt-llvm.bc): \
Output/%.nollvm-ldopt-llvm.bc: Output/%.linked.bc $(LLVMLDPROG)
	-$(LLVMLD) -disable-opt $(STATS) $(LLVMLD_FLAGS) $< -lc $(LIBS) -o Output/$*.nollvm-ldopt-llvm

$(PROGRAMS_TO_TEST:%=Output/%.nollvm-ldopt-llvm): \
Output/%.nollvm-ldopt-llvm: Output/%.linked.rbc $(LLVMLDPROG)
	-$(LLVMLD) -disable-opt $(STATS) $(LLVMLD_FLAGS) $< -lc $(LIBS)  -o Output/$*.nollvm-ldopt-llvm

endif   # ifndef DISABLE_FOR_LLVM_PROGRAMS

# Targets to get the pass arguments that opt and llvm-ld are using...
Output/opt-pass-args: $(LOPT) Output/.dir
	-$(LLVMAS) < /dev/null -o - | \
	  $(LOPT) $(EXTRA_LOPT_OPTIONS) -std-compile-opts -disable-output -debug-pass=Arguments 2>&1 | \
	  sed 's/Pass Arguments: //' > $@

Output/llvm-ld-pass-args: $(LLVMLDPROG) Output/.dir
	$(LLVMAS) < /dev/null > Output/llvm-ld.test.bc
	$(LLVMLD) Output/llvm-ld.test.bc -o Output/llvm-ld.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
# PPC and X86 support DWARF exceptions, for everything else, default to SJLJ
ifeq ($(ARCH),PowerPC)
LLCFLAGS += -enable-eh
else
ifeq ($(ARCH),x86)
LLCFLAGS += -enable-eh
else
LLCFLAGS += -enable-correct-eh-support
LLVMLD_FLAGS += -disable-inlining
endif
endif
endif

# Pass target specific llc flags
ifdef TARGET_LLCFLAGS
LLCFLAGS += $(TARGET_LLCFLAGS)
endif

# It is important to link C++ programs with G++ so look for -lstdc++ in LDFLAGS
# and set the LLVMGCCLD variable to the correct compiler interface to use.
ifneq ($(filter -lstdc++,$(LDFLAGS)),)
LLVMGCCLD := $(CXX) 
else
LLVMGCCLD := $(CC)
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) $< -o $@ $(LDFLAGS) $(CFLAGS) $(OPTFLAGS) -fno-strict-aliasing -fno-inline $(TARGET_FLAGS) $(LIBS)

#
# 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 $@

# On darwin, pass -force_cpusubtype_ALL to allow all ppc instructions.
ifeq ($(ARCH),PowerPC)
LLCASSEMBLERFLAGS = -force_cpusubtype_ALL
endif
# On sparc, pass -mcpu=v9 to allow all V9 instructions, even in 32-bit mode.
ifeq ($(ARCH),Sparc)
LLCASSEMBLERFLAGS = -mcpu=v9
endif

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

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


#
# 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 --disable-core-files $(EXTRA_LLI_OPTS)
JIT_OPTS = -force-interpreter=false --disable-core-files $(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
ifndef USE_REFERENCE_OUTPUT
$(PROGRAMS_TO_TEST:%=Output/%.out-nat): \
Output/%.out-nat: Output/%.native
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)
endif
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)

$(PROGRAMS_TO_TEST:%=Output/%.out-jit-beta): \
Output/%.out-jit-beta: Output/%.llvm.bc $(LLI)
	-$(RUNSAFELY) $(STDIN_FILENAME) $@ $(LLI) $(LLCBETAOPTION) $(JIT_OPTS) $< $(RUN_OPTIONS)

$(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)

# The RunSafely.sh script puts an "exit <retval>" line at the end of
# the program's output. We have to make bugpoint do the same thing
# or else it will get false positives when it diff's the reference
# output with the program's output.
BUGPOINT_OPTIONS += -append-exit-code

# Support remote execution
ifdef REMOTE_HOST
ifdef REMOTE_USER
BUGPOINT_OPTIONS += -rsh-host=$(REMOTE_HOST) -rsh-user=$(REMOTE_USER)
else
BUGPOINT_OPTIONS += -rsh-host=$(REMOTE_HOST)
endif
endif

# 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

ifdef DISABLE_LOOP_EXTRACT
BUGPOINT_OPTIONS += -disable-loop-extraction
endif

# Give bugpoint information about LDFLAGS to pass down to the actual link stage
# of the program.
BUGPOINT_OPTIONS += $(LDFLAGS:%=-Xlinker=%) $(EXTRA_OPTIONS:%=-Xlinker=%)

# 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 opt, llvm-ld, llc, or lli commands...
$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-opt): \
Output/%.bugpoint-opt: Output/%.noopt-llvm.bc $(LBUGPOINT) \
                         Output/opt-pass-args Output/%.out-nat
	$(LBUGPOINT) $< `cat Output/opt-pass-args` $(BUGPOINT_OPTIONS) $(BUGPOINT_ARGS)

$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-llvm-ld): \
Output/%.bugpoint-llvm-ld: Output/%.nollvm-ldopt-llvm.bc $(LBUGPOINT) \
                         Output/llvm-ld-pass-args Output/%.out-nat
	$(LBUGPOINT) $< `cat Output/llvm-ld-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)

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

$(PROGRAMS_TO_TEST:%=Output/%.misopt.out): \
Output/%.misopt.out: Output/%.linked.rbc $(LFINDMISOPT) 
	$(LFINDMISOPT) $< Output/$*.misopt "$(RUN_OPTIONS)" \
	  "$(STDIN_FILENAME)" > Output/$*.misopt.out 2>&1

clean::
	rm -f bugpoint-* 
	rm -rf Output/misopt-*

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
	-rm -f $@
	-cp $< $@

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

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

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

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

$(PROGRAMS_TO_TEST:%=Output/%.exe-cbe): \
Output/%.exe-cbe: Output/%.diff-cbe
	-rm -f $@
	-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 $< $@

$(PROGRAMS_TO_TEST:%=Output/%.LOC.txt): \
Output/%.LOC.txt: $(SRCDIR)/%.LOC.txt Output/.dir
	cp $< $@
else 
ifdef USE_REFERENCE_OUTPUT
# In this case, we opt out of generating the native output and just
# copy it from a reference output
$(PROGRAMS_TO_TEST:%=Output/%.out-nat): \
Output/%.out-nat: $(PROJ_SRC_DIR)/%.reference_output Output/.dir
	cp $< $@
endif
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