blob: fd609b6dacb082759de625afbcf010b3cf59d273 [file] [log] [blame]
##===- test/Programs/Makefile.programs ---------------------*- Makefile -*-===##
#
# This makefile contains all of the makefile machinery that is common to
# building stuff in the Programs 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/Programs/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)/test/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 = $(LLVM_SRC_ROOT)/test/Programs
#
# Scripts in the Programs directory...
#
# TIMEPROG - The program used to get timing results for a program
TIMEPROG := $(PROGDIR)/TimeProgram.sh
# DIFFPROG - The program used to diff the output
DIFFPROG := $(PROGDIR)/DiffOutput.sh
# 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.
RUNSAFELY := $(PROGDIR)/RunSafely.sh $(RUNTIMELIMIT)
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))
# Generated code for llc (which does not require the target platform)
LLCCODEGEN := $(addsuffix .llc.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))
LLCOUTPUT := $(addsuffix .out-llc, $(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))
LLCDIFFS := $(addsuffix .diff-llc, $(PREFIXED_PROGRAMS_TO_TEST))
CBEDIFFS := $(addsuffix .diff-cbe, $(PREFIXED_PROGRAMS_TO_TEST))
# Build Program outputs:
.PRECIOUS: Output/%.out-lli Output/%.out-jit Output/%.out-llc
.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-cbe
# Regardless of what other options are specified, build the program's bytecode
# representation.
all:: $(BYTECODE)
ifdef RUN_GCC_ONLY
DISABLE_DIFFS = 1
all:: $(GCCOUTPUT)
endif
ifdef DISABLE_FOR_LLVM_PROGRAMS
DISABLE_DIFFS := 1
endif
ifneq ($(TRACE)$(TRACEM),)
## When tracing is enabled do the following:
## -- disable output diffs
## -- generate llc output if not disabled
## -- generate cbe output if not disabled
## -- Make the trace output files precious if tracing is enabled because
## we often don't want to generate the complete trace file!
DISABLE_DIFFS = 1
OPTPASSES += $(TRACEFLAGS)
LDFLAGS += $(TRACELIBS)
ifndef DISABLE_LLC
all:: $(LLCOUTPUT)
endif
ifndef DISABLE_CBE
all:: $(CBEOUTPUT)
endif
ifndef DISABLE_JIT
all:: $(JITOUTPUT)
endif
.PRECIOUS: $(LLIOUTPUT) $(JITOUTPUT) $(LLCOUTPUT) $(CBEOUTPUT)
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)
endif
ifndef DISABLE_CBE_DIFFS
all:: $(CBEDIFFS)
endif
ifdef TARGET_HAS_JIT
ifndef DISABLE_JIT
all:: $(JITDIFFS)
endif
endif
ifdef ENABLE_LLI
all:: $(LLIDIFFS)
endif
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 $@
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) $< -lgcc -lc $(LIBS) crtend.o -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) $< -lgcc -lc $(LIBS) crtend.o -o Output/$*.llvm
ifneq ($(OPTPASSES),)
$(LOPT) -q $(OPTPASSES) < $@ > $@.tmp
$(MV) -f $@.tmp $@
endif
endif # ifndef DISABLE_FOR_LLVM_PROGRAMS
# Targets to get the pass arguments that gccas and gccld are using...
Output/gccas-pass-args: $(LGCCAS)
$(LGCCAS) /dev/null -o /dev/null -debug-pass=Arguments > $@.1 2>&1
sed 's/Pass Arguments: //' < $@.1 > $@
Output/gccld-pass-args: $(TOOLS)/gccld
$(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 > $@
# Specify stdin, reference output, and command line options for the program...
BUGPOINT_OPTIONS += -input=$(STDIN_FILENAME) -output=Output/$*.out-nat
BUGPOINT_OPTIONS += --args -- $(RUN_OPTIONS)
# Rules to bugpoint the GCCAS or GCCLD command...
$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-gccas): \
Output/%.bugpoint-gccas: Output/%.linked.rll $(LBUGPOINT) \
Output/gccas-pass-args Output/%.out-nat
$(LBUGPOINT) $< `cat Output/gccas-pass-args` $(BUGPOINT_OPTIONS)
$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-gccld): \
Output/%.bugpoint-gccld: Output/%.linked.bc $(LBUGPOINT) \
Output/gccld-pass-args Output/%.out-nat
$(LBUGPOINT) $< `cat Output/gccld-pass-args` $(BUGPOINT_OPTIONS)
$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-llc): \
Output/%.bugpoint-llc: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
$(LBUGPOINT) $< -run-llc $(BUGPOINT_OPTIONS)
$(PROGRAMS_TO_TEST:%=Output/%.bugpoint-jit): \
Output/%.bugpoint-jit: Output/%.llvm.bc $(LBUGPOINT) Output/%.out-nat
$(LBUGPOINT) $< -run-jit $(BUGPOINT_OPTIONS)
#
# Rules to compile the program for the C Back End
#
$(PROGRAMS_TO_TEST:%=Output/%.cbe.c): \
Output/%.cbe.c: Output/%.llvm.bc $(LDIS)
-$(LDIS) -c < $< > $@
$(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 $@
## 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 $@
#
# 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 = -q -force-interpreter=true $(EXTRA_LLI_OPTS)
JIT_OPTS = -force-interpreter=false $(EXTRA_LLI_OPTS)
native: $(PROGRAMS_TO_TEST:%=Output/%.native)
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: $* 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-cbe): \
Output/%.out-cbe: Output/%.cbe
-$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS)
endif
#
# 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-llc): \
Output/%.diff-llc: Output/%.out-nat Output/%.out-llc
-$(DIFFPROG) llc $* $(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-llc): \
Output/%.exe-llc: Output/%.diff-llc
-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)/test/Programs; 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 $(LEVEL)/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 $(LEVEL)/test/Programs/TEST.$(TEST).Makefile) \
$(wildcard $(LEVEL)/projects/*/test/TEST.$(TEST).Makefile)
TestReport := $(wildcard $(LEVEL)/test/Programs/TEST.$(TEST).report) \
$(wildcard $(LEVEL)/projects/*/test/TEST.$(TEST).report)
TestGnuPlot := $(wildcard $(LEVEL)/test/Programs/TEST.$(TEST).gnuplot) \
$(wildcard $(LEVEL)/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 "***************************************************************"
@echo
@exit 1
endif
endif
#
# Rules for building a report from 'make report TEST=<x>'
#
GENERATEREPORT := $(LEVEL)/test/Programs/GenerateReport.pl
report.$(TEST).raw.out: $(REPORT_DEPENDENCIES) $(TestMakefile)
gmake 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.graphs: report.$(TEST).raw.out $(TestReport) $(TestGnuPlot) $(GENERATEREPORT)
$(GENERATEREPORT) -graphs $(TestReport) < $<
gnuplot $(TestGnuPlot)
report: report.$(TEST).txt
@cat $<
report.html: report.$(TEST).html
report.tex: report.$(TEST).tex
@cat $<
endif
clean::
rm -f report.*.raw.out report.*.txt