This is an archive of the discontinued LLVM Phabricator instance.

Differential D50209

cmake: Explicitely specify benchmark data
ClosedPublic

Authored by MatzeB on Aug 2 2018, 5:27 PM.

Details

Reviewers
cmatthews
kristof.beyls
Meinersbur
homerdin
tra
Commits
rOLDT340582: cmake: Explicitely specify benchmark data
rL340582: cmake: Explicitely specify benchmark data
Summary

Explicitely declare what files are used as inputs for the benchmarks.
This changes the benchmarks to:

  • Copy the related input files next to the binary into the build folder.
  • Set the working directory of the benchmark to be the folder of the executable.
  • Having the data next to the binary also reduces the amount of absolute paths in the test files.

With this change in place you do not need the test-suite source
repository anymore to run the benchmarks. This is an important step
towards having a test-suite that can be cross-compiled on a host, then
copied onto a device and ran there without having a shared filesystem
like NFS setup.

Diff Detail

Repository
rL LLVM

Event Timeline

MatzeB created this revision.Aug 2 2018, 5:27 PM
Herald added subscribers: mgorny, mcrosier. · View Herald TranscriptAug 2 2018, 5:27 PM
MatzeB added a comment.Aug 2 2018, 5:29 PM

Some notes:

  • I is only for the benchmarks shipping with the test-suite yet. The things in External will need some additional changes (they will keep working as is, just won't consistenly have their data in the builddir)
  • The copying grows the builddir from ~900MB to 1GB for me. If this is a concern then we could add a mode that creates symlinks when the test-suite is running locally; however I wasn't convinced yet it is worth having two modes just for 100MB savings in the builddir.
MatzeB updated this revision to Diff 158873.Aug 2 2018, 5:33 PM
  • properly document new cmake functions and add SUB_DIRECTORY argument to llvm_test_data_dir() for consistency.
Meinersbur added a comment.Aug 2 2018, 6:19 PM
In D50209#1186520, @MatzeB wrote:

Some notes:

  • I is only for the benchmarks shipping with the test-suite yet. The things in External will need some additional changes (they will keep working as is, just won't consistenly have their data in the builddir)
  • The copying grows the builddir from ~900MB to 1GB for me. If this is a concern then we could add a mode that creates symlinks when the test-suite is running locally; however I wasn't convinced yet it is worth having two modes just for 100MB savings in the builddir.

I am indeed concerned. The SPEC (2017) benchmark data can be >100MB per benchmark. In addition, I am adding the build dir to a git repository to see what the differences are (some file types ignored, eg object files). Having the input data in the build dir would blow up that repository, if these are symlinks.

I don't want to block this patch because of my particular setup, but it means that I need something more intelligent than some file extensions in the .gitignore of the build dir.

cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

Could we work towards a 'one call=one benchmark specification' approach? Such as

llvm_test(progname
  SOURCES ...
  CFLAGS ...
  WORKDIR ...
  RUN_OPTIONS ...
  RUN_DATA ...
  ...

I always found the different functions/macros that have to be called in a specific order and pass state between each other (TESTSCRIPT) more complex than necessary.

16 ↗(On Diff #158871)

In case of SPEC 2017, a working directory is created where (when necessary) the run data is copied to and the program writes its data to. Some benchmarks construct the input file path from a sibling dir name (run_${runtype}) to argv[0] or the current cwd.

20 ↗(On Diff #158871)

Could llvm_test_data automatically determine whether the argument is a directory/file?

MatzeB updated this revision to Diff 158882.Aug 2 2018, 6:32 PM

Fix benchmarks I missed before because they aren't built by default.

MatzeB added inline comments.Aug 2 2018, 6:51 PM
cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

Some points to this:

  • The current style of setting magic variables that are later read by llvm_singlesource()/llvm_multisource() is an effect of the original cmake build being a half-automatic translation from the makefiles. It's terrible style to have magic variables without obvious clues to the user that they have an effect on the two calls (rather than being temporary variables). We only do this style for llvm_singlesource()/llvm_multisource() and I consider it deprecated (= the ugly stuff is in cmake/modules/SingleMultiSource.cmake and considered deprecated.
  • The next interesting discussion is about:
llvm_test(name
  FOO ...
  BAR ...
  BAZ ...
)

compared to

llvm_test(name)
llvm_test_foo(name ...)
llvm_test_bar(name ...)
llvm_test_baz(name ....)

The former is a more compact syntax and avoids repeating the target name.
However it is bad for modularity/extensibility. The 2nd style makes it more natural to invent convenience functions (that are only used for some macros) and still have them naturally integrate into the flow of things without feeling out of place.

In practice I would aim for a compromise here: Only include the very basic options that the big majority of benchmarks will use in the basic command, and have everything else as an additional call on the target that you can perform afterwards... (say progname, SOURCES, CFLAGS in there and keep the test run/verification stuff in a separate command, ...)

16 ↗(On Diff #158871)

I guess we can experiment some more with symlinks (as in we symlink to the builddir and the copying is relative to this symlink...). That said I'd be fine to simply not convert SPEC2017 to the "everything in the build directory" style for now, it'll just keep working as is (the new style/not new style will only make a difference for setups when you test on external devices without having a shared filesystem).

20 ↗(On Diff #158871)

Good idea, that should be possible.

MatzeB updated this revision to Diff 158885.Aug 2 2018, 7:01 PM

Let llvm_test_data() handle directories so we don't need a separate llvm_test_data_dir().

Meinersbur accepted this revision.Aug 20 2018, 10:38 AM

I am ok with committing this, but maybe we should have someone else's opinion as well?

cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

One of the problems with second style is that not all details are available in each llvm_test_*. For instance, e.g. SPEC 2017, have programs that have to be compiled for verification (such as convert compressed images to the plain format the reference images are in). To compile these programs, CFLAGS are needed as well.

However, this is not the topic of this patch.

16 ↗(On Diff #158871)

It would be nice if we could handle all benchmarks using the same mechanisms in some future.

This revision is now accepted and ready to land.Aug 20 2018, 10:38 AM
MatzeB updated this revision to Diff 161592.Aug 20 2018, 3:39 PM

Updated patch:

  • Update External benchmarks to specify llvm_test_data() as well.
  • Create a symbolic link for the data by default. The MUST_COPY argument to llvm_test_data() forces a copy where necessary. I plan to add a global setting in upcoming patches, that allow users to always force a copy instead of a symlink when running on an external device without shared filesystem.
MatzeB added a comment.Aug 20 2018, 3:45 PM

I am ok with committing this, but maybe we should have someone else's opinion as well?

I'm not sure there are many other people around that care about how the test-suite cmake files are written. That said I think @cmatthews cares about being able to run the test-suite in a setup without NFS as well.

cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

Not sure I completely understand the situation with spec2017, can you point me to a specific benchmark in spec2017 that shows this?

In general if there is a situations where steps need to communicate with each other such as passing along CFLAGS then we could attach them as properties to the target...

16 ↗(On Diff #158871)

My latest patch creates symlinks by default instead of copying the data. So there shouldn't be a reason anymore not to use llvm_test_data() for spec 2017 as well... (Though I will not do the transition right now as I cannot test things for spec 2017)

Meinersbur added inline comments.Aug 20 2018, 4:23 PM
cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

511.povray_r, 526.blender_r, 538.imagick_r, 525.x264_r

These call speccpu2017_validate_image, which compiles a validator program. The validator program requires as least -DSPEC to be added, which is atm hardcoded into speccpu2017_validate_image.

One could indeed set all options as target properties and have a call at the end such as llvm_test_finished() (In SPEC2017 this would be speccpu2017_add_executable). However, the target must already have been created using add_executable. Some of the target's details cannot be changed after that, such as the target's name itself (even now it is possible to change alter the target name using the PREFIX argument, but it is not passed to the lit modules for collecting executable size, statistics, etc, which already has caused problems for me).

On the other hand, I agree that specifying multiple executions such as speccpu2017_run_test does is nicer to have different invocations for, instead of a single giant call that defines all RUN lines.

MatzeB added inline comments.Aug 20 2018, 4:30 PM
cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

even now it is possible to change alter the target name using the PREFIX argument, but it is not passed to the lit modules for collecting executable size, statistics, etc, which already has caused problems for me

I recently changed this in r338622: PREFIX can only be used with llvm_singlesource() anymore, so here and in many other situations you can stop worrying :)

Meinersbur added inline comments.Aug 20 2018, 5:29 PM
cmake/modules/TestSuite.cmake
9–25 ↗(On Diff #158871)

The problem with PREFIX also applies to llvm_singlesource.

In my case, I added a newer version of Polybench (v4.2.1b) to the test-suite. Because its executable names clash with Polybench v3.2 which is already in a test-suite, I set the the PREFIX.

stats.py and compiletime.py used to identify the prefix by searching for the first dash in the executable name. In another commit (r286276) the dash was made optional.

The code to identify the correct object file is still:

prefix = ""
if context.config.single_source:
    prefix = "%s." % os.path.basename(context.executable)

The field context.executable is derived from the target name, i.e. includes the prefix. But the object file name is derived from the filename, i.e. does not contain the prefix. That is, no .o.time file will ever match if a prefix is used.

We are somewhat off-topic here. This is just to illustrate that some test arguments may be required for a different cmake-macro than it is passed to. Here, I ended up passing all benchmark source files in the .test file such that the python script can directly derive the .o.time or .stat file and I am sure that no such file is missed during a directory traversal. This required that one of the macros in TestFile.cmake is passed the list of source files, not just llvm_test_executable.

MatzeB added a child revision: D51048: cmake: Specify reference outputs in llvm_test_data().Aug 21 2018, 10:36 AM
Closed by commit rL340582: cmake: Explicitely specify benchmark data (authored by matze). · Explain WhyAug 23 2018, 3:35 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
test-suite/
trunk/
External/
HMMER/
12 lines
Nurbs/
6 lines
Povray/
13 lines
SPEC/
CFP2000/
177.mesa/
19 lines
179.art/
22 lines
183.equake/
14 lines
188.ammp/
14 lines
1 line
CFP2006/
433.milc/
17 lines
444.namd/
17 lines
447.dealII/
32 lines
450.soplex/
33 lines
453.povray/
25 lines
470.lbm/
13 lines
482.sphinx3/
42 lines
CINT2000/
164.gzip/
14 lines
175.vpr/
44 lines
176.gcc/
13 lines
181.mcf/
19 lines
186.crafty/
14 lines
197.parser/
12 lines
252.eon/
33 lines
253.perlbmk/
75 lines
254.gap/
17 lines
255.vortex/
15 lines
256.bzip2/
13 lines
300.twolf/
16 lines
1 line
CINT2006/
400.perlbench/
44 lines
401.bzip2/
36 lines
403.gcc/
13 lines
429.mcf/
19 lines
445.gobmk/
12 lines
456.hmmer/
27 lines
458.sjeng/
13 lines
462.libquantum/
16 lines
464.h264ref/
24 lines
471.omnetpp/
23 lines
473.astar/
14 lines
483.xalancbmk/
11 lines
CINT95/
099.go/
10 lines
124.m88ksim/
13 lines
126.gcc/
13 lines
129.compress/
12 lines
130.li/
10 lines
132.ijpeg/
10 lines
134.perl/
12 lines
147.vortex/
17 lines
8 lines
9 lines
9 lines
skidmarks10/
6 lines
MultiSource/
Applications/
ALAC/
decode/
3 lines
encode/
3 lines
Burg/
3 lines
ClamAV/
35 lines
JM/
ldecod/
4 lines
lencod/
11 lines
SIBsim4/
6 lines
SPASS/
6 lines
d/
3 lines
hbd/
3 lines
hexxagon/
3 lines
kimwitu++/
4 lines
lambda-0.1.3/
4 lines
lemon/
4 lines
lua/
1 line
minisat/
8 lines
obsequi/
3 lines
oggenc/
3 lines
siod/
3 lines
spiff/
3 lines
sqlite3/
4 lines
treecc/
3 lines
viterbi/
3 lines
Benchmarks/
ASC_Sequoia/
IRSmk/
3 lines
BitBench/
drop3/
3 lines
five11/
3 lines
uudecode/
3 lines
uuencode/
3 lines
DOE-ProxyApps-C++/
PENNANT/
3 lines
DOE-ProxyApps-C/
Pathfinder/
3 lines
SimpleMOC/
3 lines
Fhourstones-3.1/
6 lines
Fhourstones/
3 lines
FreeBench/
analyzer/
6 lines
distray/
6 lines
fourinarow/
6 lines
mason/
6 lines
neural/
6 lines
pcompress2/
12 lines
pifft/
6 lines
MallocBench/
espresso/
3 lines
gawk/
3 lines
gs/
30 lines
make/
3 lines
p2c/
3 lines
perl/
3 lines
McCat/
01-qbsort/
3 lines
03-testtrie/
3 lines
04-bisect/
3 lines
09-vor/
3 lines
15-trie/
3 lines
17-bintr/
3 lines
18-imp/
3 lines
MiBench/
automotive-susan/
3 lines
consumer-jpeg/
3 lines
consumer-lame/
3 lines
consumer-typeset/
3 lines
network-dijkstra/
3 lines
network-patricia/
3 lines
office-ispell/
3 lines
security-rijndael/
3 lines
security-sha/
3 lines
telecomm-CRC32/
3 lines
telecomm-adpcm/
3 lines
telecomm-gsm/
3 lines
PAQ8p/
8 lines
Prolangs-C++/
employ/
3 lines
Prolangs-C/
agrep/
3 lines
bison/
3 lines
cdecl/
3 lines
gnugo/
3 lines
unix-smail/
3 lines
Ptrdist/
anagram/
3 lines
bc/
3 lines
ks/
3 lines
yacr2/
3 lines
Rodinia/
hotspot/
1 line
srad/
1 line
Trimaran/
netbench-url/
7 lines
VersaBench/
8b10b/
5 lines
dbms/
7 lines
mafft/
4 lines
mediabench/
adpcm/
rawcaudio/
5 lines
rawdaudio/
5 lines
g721/
g721encode/
5 lines
gsm/
toast/
5 lines
jpeg/
jpeg-6a/
5 lines
mpeg2/
mpeg2dec/
5 lines
nbench/
9 lines
sim/
5 lines
cmake/
modules/
14 lines
5 lines
29 lines

Diff 162281

test-suite/trunk/External/HMMER/CMakeLists.txt

include(External) include(External)
llvm_externals_find(TEST_SUITE_HMMER_ROOT "hmmer" "HMMER 2.3.2") llvm_externals_find(TEST_SUITE_HMMER_ROOT "hmmer" "HMMER 2.3.2")
if(TEST_SUITE_HMMER_ROOT) if(TEST_SUITE_HMMER_ROOT)
list(APPEND CFLAGS -pthread) list(APPEND CFLAGS -pthread)
list(APPEND LDFLAGS -pthread) list(APPEND LDFLAGS -pthread)
if(ARCH STREQUAL "PowerPC") if(ARCH STREQUAL "PowerPC")
list(APPEND CFLAGS -maltivec) list(APPEND CFLAGS -maltivec)
list(APPEND LDFLAGS -maltivec) list(APPEND LDFLAGS -maltivec)
endif() endif()
if(ARCH STREQUAL "x86") if(ARCH STREQUAL "x86")
add_definitions(-DSSE2) add_definitions(-DSSE2)
endif() endif()
llvm_test_prepare(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
cp -f globin.hmm run.hmm
)
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
llvm_test_run(--fixed 400 --cpu 1 --num 200000 --seed 1158818515 ${TEST_SUITE_HMMER_ROOT}/globin.hmm) llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
--fixed 400 --cpu 1 --num 200000 --seed 1158818515 run.hmm
)
else() else()
llvm_test_run(--fixed 400 --cpu 1 --num 80000 --seed 1158818515 ${TEST_SUITE_HMMER_ROOT}/globin.hmm) llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
--fixed 400 --cpu 1 --num 80000 --seed 1158818515 run.hmm
)
endif() endif()
FILE(GLOB SOURCES ${TEST_SUITE_HMMER_ROOT}/*.c) FILE(GLOB SOURCES ${TEST_SUITE_HMMER_ROOT}/*.c)
llvm_test_executable(hmmcalibrate ${SOURCES}) llvm_test_executable(hmmcalibrate ${SOURCES})
llvm_test_data(hmmcalibrate SOURCE_DIR ${TEST_SUITE_HMMER_ROOT} globin.hmm)
endif() endif()

test-suite/trunk/External/Nurbs/CMakeLists.txt

# Nurbs uses SSE and only works on x86. # Nurbs uses SSE and only works on x86.
if(ARCH STREQUAL "x86") if(ARCH STREQUAL "x86")
include(External) include(External)
llvm_externals_find(TEST_SUITE_NURBS_ROOT "nurbs" "Nurbs") llvm_externals_find(TEST_SUITE_NURBS_ROOT "nurbs" "Nurbs")
if(TEST_SUITE_NURBS_ROOT) if(TEST_SUITE_NURBS_ROOT)
list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
if(CMAKE_SIZEOF_VOID_P EQUAL 8) if(CMAKE_SIZEOF_VOID_P EQUAL 8)
list(APPEND CPPFLAGS -DDWORD_IS_ULL) list(APPEND CPPFLAGS -DDWORD_IS_ULL)
endif() endif()
llvm_test_run(/k all timed /t 500 /vsteps 192 /usteps 192 /vcp 20 /ucp 20) llvm_test_run(/k all timed /t 500 /vsteps 192 /usteps 192 /vcp 20 /ucp 20)
llvm_test_verify(${FPCMP} llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
%o ${FPCMP} %o nurbs.reference_output
${CMAKE_CURRENT_SOURCE_DIR}/nurbs.reference_output
) )
file(GLOB SOURCES ${TEST_SUITE_NURBS_ROOT}/*.cpp) file(GLOB SOURCES ${TEST_SUITE_NURBS_ROOT}/*.cpp)
llvm_test_executable(nurbs ${SOURCES}) llvm_test_executable(nurbs ${SOURCES})
llvm_test_data(nurbs nurbs.reference_output)
file(COPY lit.local.cfg DESTINATION "${CMAKE_CURRENT_BINARY_DIR}") file(COPY lit.local.cfg DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
endif() endif()
endif() endif()

test-suite/trunk/External/Povray/CMakeLists.txt

Show All 15 Lines list(APPEND CPPFLAGS
-I${TEST_SUITE_POVRAY_ROOT}/source -I${TEST_SUITE_POVRAY_ROOT}/source
-I${TEST_SUITE_POVRAY_ROOT}/source/unix -I${TEST_SUITE_POVRAY_ROOT}/source/unix
-I${TEST_SUITE_POVRAY_ROOT}/source/libpng -I${TEST_SUITE_POVRAY_ROOT}/source/libpng
-DPREFIX="${CMAKE_CURRENT_BINARY_DIR}" -DPREFIX="${CMAKE_CURRENT_BINARY_DIR}"
-DSYSCONFDIR="${CMAKE_CURRENT_BINARY_DIR}" -DSYSCONFDIR="${CMAKE_CURRENT_BINARY_DIR}"
) )
list(APPEND LDFLAGS -lz -lm) list(APPEND LDFLAGS -lz -lm)
llvm_test_run( llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-I${TEST_SUITE_POVRAY_ROOT}/scenes/advanced/chess2.pov -Iscenes/advanced/chess2.pov
-L${TEST_SUITE_POVRAY_ROOT}/include -Linclude
-GA/dev/null -O- -GA/dev/null -O-
) )
llvm_test_verify(${FPCMP} llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
%o ${FPCMP} %o povray.reference_output
${CMAKE_CURRENT_SOURCE_DIR}/povray.reference_output
) )
llvm_test_executable(povray ${Source}) llvm_test_executable(povray ${Source})
llvm_test_data(povray povray.reference_output)
llvm_test_data(povray SOURCE_DIR ${TEST_SUITE_POVRAY_ROOT} scenes include)
file(COPY lit.local.cfg DESTINATION "${CMAKE_CURRENT_BINARY_DIR}") file(COPY lit.local.cfg DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
endif() endif()

test-suite/trunk/External/SPEC/CFP2000/177.mesa/CMakeLists.txt

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesforeach(Filename ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${Filename}) list(APPEND Source ${BENCHMARK_DIR}/src/${Filename})
endforeach() endforeach()
macro(test_input run_type frames) macro(test_input run_type frames)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
-frames ${frames} -meshfile mesa.in -ppmfile mesa.ppm -frames ${frames} -meshfile mesa.in -ppmfile mesa.ppm
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/mesa.log ${FPCMP} data/${run_type}/output/mesa.log data/${run_type}/input/mesa.log
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/mesa.log
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 6.0 ${FPCMP} -a 6.0 data/${run_type}/output/mesa.ppm data/${run_type}/input/mesa.ppm
${BENCHMARK_DIR}/data/${run_type}/output/mesa.ppm
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/mesa.ppm
) )
endmacro() endmacro()
test_input(test 10) test_input(test 10)
test_input(train 500) test_input(train 500)
test_input(ref 1000) test_input(ref 1000)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(177.mesa ${Source})
llvm_test_data_spec(177.mesa MUST_COPY data)
# The benchmark writes the output where the input files are, so we have to
# copy the data over.
include(CopyDir)
llvm_copy_dir(177.mesa ${CMAKE_CURRENT_BINARY_DIR}/data ${BENCHMARK_DIR}/data)

test-suite/trunk/External/SPEC/CFP2000/179.art/CMakeLists.txt

macro(test_input run_type output) macro(test_input run_type output)
llvm_test_run(RUN_TYPE ${run_type} ${ARGN} > "${CMAKE_CURRENT_BINARY_DIR}/${output}") llvm_test_run(RUN_TYPE ${run_type}
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} ${ARGN} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
-r 0.01 )
"${BENCHMARK_DIR}/data/${run_type}/output/${output}" llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
"${CMAKE_CURRENT_BINARY_DIR}/${output}" ${FPCMP} -r 0.01 data/${run_type}/output/${output} ${output}
) )
endmacro() endmacro()
set(DATADIR ${BENCHMARK_DIR}/data)
test_input(test test.out test_input(test test.out
WORKDIR ${DATADIR}/test/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
-scanfile c756hel.in -scanfile c756hel.in
-trainfile1 a10.img -trainfile1 a10.img
-stride 2 -stride 2
-startx 134 -startx 134
-starty 220 -starty 220
-endx 139 -endx 139
-endy 225 -endy 225
-objects 1 -objects 1
) )
test_input(train train.out test_input(train train.out
WORKDIR ${DATADIR}/train/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/train/input
-scanfile c756hel.in -scanfile c756hel.in
-trainfile1 a10.img -trainfile1 a10.img
-stride 2 -stride 2
-startx 134 -startx 134
-starty 220 -starty 220
-endx 184 -endx 184
-endy 240 -endy 240
-objects 3 -objects 3
) )
test_input(ref ref.1.out test_input(ref ref.1.out
WORKDIR ${DATADIR}/ref/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
-scanfile c756hel.in -scanfile c756hel.in
-trainfile1 a10.img -trainfile1 a10.img
-trainfile2 hc.img -trainfile2 hc.img
-stride 2 -stride 2
-startx 110 -startx 110
-starty 200 -starty 200
-endx 160 -endx 160
-endy 240 -endy 240
-objects 10 -objects 10
) )
test_input(ref ref.2.out test_input(ref ref.2.out
WORKDIR ${DATADIR}/ref/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
-scanfile c756hel.in -scanfile c756hel.in
-trainfile1 a10.img -trainfile1 a10.img
-trainfile2 hc.img -trainfile2 hc.img
-stride 2 -stride 2
-startx 470 -startx 470
-starty 140 -starty 140
-endx 520 -endx 520
-endy 180 -endy 180
-objects 10 -objects 10
) )
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(179.art ${Source})
llvm_test_data_spec_default(179.art)

test-suite/trunk/External/SPEC/CFP2000/183.equake/CMakeLists.txt

macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
< "${BENCHMARK_DIR}/data/${run_type}/input/inp.in" < data/${run_type}/input/inp.in > inp.out
> "${CMAKE_CURRENT_BINARY_DIR}/inp.out"
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.00001 ${FPCMP} -r 0.00001 data/${run_type}/output/inp.out inp.out
"${BENCHMARK_DIR}/data/${run_type}/output/inp.out"
"${CMAKE_CURRENT_BINARY_DIR}/inp.out"
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(183.equake ${Source})
llvm_test_data_spec_default(183.equake)

test-suite/trunk/External/SPEC/CFP2000/188.ammp/CMakeLists.txt

macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
< ${BENCHMARK_DIR}/data/${run_type}/input/ammp.in < ammp.in > ${CMAKE_CURRENT_BINARY_DIR}/ammp.out
> "${CMAKE_CURRENT_BINARY_DIR}/ammp.out"
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.003 -a 0.0001 ${FPCMP} -r 0.003 -a 0.0001 data/${run_type}/output/ammp.out ammp.out
"${BENCHMARK_DIR}/data/${run_type}/output/ammp.out"
"${CMAKE_CURRENT_BINARY_DIR}/ammp.out"
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(188.ammp ${Source})
llvm_test_data_spec_default(188.ammp)

test-suite/trunk/External/SPEC/CFP2000/CMakeLists.txt

include(${CMAKE_SOURCE_DIR}/External/SPEC/SpecCPU2000.cmake) include(${CMAKE_SOURCE_DIR}/External/SPEC/SpecCPU2000.cmake)
if(TEST_SUITE_SPEC2000_ROOT) if(TEST_SUITE_SPEC2000_ROOT)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(cfp2000_subdir BENCHMARK) macro(cfp2000_subdir BENCHMARK)
set(BENCHMARK_DIR ${TEST_SUITE_SPEC2000_ROOT}/benchspec/CFP2000/${BENCHMARK}) set(BENCHMARK_DIR ${TEST_SUITE_SPEC2000_ROOT}/benchspec/CFP2000/${BENCHMARK})
set(PROG ${BENCHMARK})
file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp) file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp)
add_subdirectory(${BENCHMARK}) add_subdirectory(${BENCHMARK})
endmacro() endmacro()
cfp2000_subdir(177.mesa) cfp2000_subdir(177.mesa)
cfp2000_subdir(179.art) cfp2000_subdir(179.art)
cfp2000_subdir(183.equake) cfp2000_subdir(183.equake)
cfp2000_subdir(188.ammp) cfp2000_subdir(188.ammp)
endif() endif()

test-suite/trunk/External/SPEC/CFP2006/433.milc/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
include_directories(${BENCHMARK_DIR}/src) include_directories(${BENCHMARK_DIR}/src)
add_definitions(-DFN -DFAST -DCONGRAD_TMP_VECTORS -DDSLASH_TMP_LINKS) add_definitions(-DFN -DFAST -DCONGRAD_TMP_VECTORS -DDSLASH_TMP_LINKS)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
< ${BENCHMARK_DIR}/data/${run_type}/input/su3imp.in < data/${run_type}/input/su3imp.in
> ${CMAKE_CURRENT_BINARY_DIR}/su3imp.out > su3imp.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.0001 -a 0.0000002 ${FPCMP} -r 0.0001 -a 0.0000002
${BENCHMARK_DIR}/data/${run_type}/output/su3imp.out data/${run_type}/output/su3imp.out
${CMAKE_CURRENT_BINARY_DIR}/su3imp.out su3imp.out
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(433.milc ${Source})
llvm_test_data_spec_default(433.milc)

test-suite/trunk/External/SPEC/CFP2006/444.namd/CMakeLists.txt

Show All 11 Linesset(SourceNames
spec_namd.C spec_namd.C
) )
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type iters) macro(test_input run_type iters)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
--input ${BENCHMARK_DIR}/data/all/input/namd.input --input data/all/input/namd.input
--iterations ${iters} --iterations ${iters}
--output ${CMAKE_CURRENT_BINARY_DIR}/namd.out --output namd.out
> ${CMAKE_CURRENT_BINARY_DIR}/namd.stdout > namd.stdout
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 0.00001 ${FPCMP} -a 0.00001 data/${run_type}/output/namd.out namd.out
${BENCHMARK_DIR}/data/${run_type}/output/namd.out
${CMAKE_CURRENT_BINARY_DIR}/namd.out
) )
endmacro() endmacro()
test_input(test 1) test_input(test 1)
test_input(train 1) test_input(train 1)
test_input(ref 38) test_input(ref 38)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(444.namd ${Source})
llvm_test_data_spec_default(444.namd)

test-suite/trunk/External/SPEC/CFP2006/447.dealII/CMakeLists.txt

include_directories(${BENCHMARK_DIR}/src/include) include_directories(${BENCHMARK_DIR}/src/include)
add_definitions(-DBOOST_DISABLE_THREADS -Ddeal_II_dimension=3) add_definitions(-DBOOST_DISABLE_THREADS -Ddeal_II_dimension=3)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CXXFLAGS -std=gnu++98) list(APPEND CXXFLAGS -std=gnu++98)
macro(verify_n run_type dir n) macro(verify_n run_type dir n)
# Note that the official SPEC fp tolarence is only "-a .0000001", however this # Note that the official SPEC fp tolarence is only "-a .0000001", however this
# has proven to only work reliably for x86 targets/libm. # has proven to only work reliably for x86 targets/libm.
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 1e-5 -r 1e-5 ${FPCMP} -a 1e-5 -r 1e-5
${BENCHMARK_DIR}/data/${dir}/output/grid-${n}.eps data/${dir}/output/grid-${n}.eps
${CMAKE_CURRENT_BINARY_DIR}/grid-${n}.eps grid-${n}.eps
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 1e-5 -r 1e-5 ${FPCMP} -a 1e-5 -r 1e-5
${BENCHMARK_DIR}/data/${dir}/output/solution-${n}.gmv data/${dir}/output/solution-${n}.gmv
${CMAKE_CURRENT_BINARY_DIR}/solution-${n}.gmv solution-${n}.gmv
) )
endmacro() endmacro()
macro(test_input run_type size) macro(test_input run_type size)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${size} ${size}
> ${CMAKE_CURRENT_BINARY_DIR}/log > log
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 1e-5 -r 1e-5 ${FPCMP} -a 1e-5 -r 1e-5
${BENCHMARK_DIR}/data/${run_type}/output/log data/${run_type}/output/log
${CMAKE_CURRENT_BINARY_DIR}/log log
) )
foreach(i RANGE 0 8) foreach(i RANGE 0 8)
verify_n(${run_type} all ${i}) verify_n(${run_type} all ${i})
endforeach() endforeach()
if(${size} GREATER 8) if(${size} GREATER 8)
foreach(i RANGE 9 ${size}) foreach(i RANGE 9 ${size})
verify_n(${run_type} ${run_type} ${i}) verify_n(${run_type} ${run_type} ${i})
endforeach() endforeach()
endif() endif()
endmacro() endmacro()
test_input(test 8) test_input(test 8)
test_input(train 10) test_input(train 10)
test_input(ref 23) test_input(ref 23)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(447.dealII ${Source})
llvm_test_data_spec_default(447.dealII)

test-suite/trunk/External/SPEC/CFP2006/450.soplex/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CXXFLAGS -std=gnu++98) list(APPEND CXXFLAGS -std=gnu++98)
macro(test_input run_type input outname stdout_reltol info_reltol) macro(test_input run_type input outname stdout_reltol info_reltol)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
${ARGN} ${input}
> ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${outname}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${ARGN} ${input} > ${outname}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r ${stdout_reltol} -a 1.0e-5 ${FPCMP} -r ${stdout_reltol} -a 1.0e-5
${BENCHMARK_DIR}/data/${run_type}/output/${outname} data/${run_type}/output/${outname}
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${outname} data/${run_type}/input/${outname}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r ${info_reltol} -a 20 ${FPCMP} -r ${info_reltol} -a 20
${BENCHMARK_DIR}/data/${run_type}/output/${input}.info data/${run_type}/output/${input}.info
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${input}.info data/${run_type}/input/${input}.info
) )
endmacro() endmacro()
test_input(test test.mps test.out 0.0001 1.0 -m10000) test_input(test test.mps test.out 0.0001 1.0 -m10000)
test_input(train train.mps train.out 0.02 0.0001 -m1200) test_input(train train.mps train.out 0.02 0.0001 -m1200)
test_input(train pds-20.mps pds-20.mps.out 0.02 0.0001 -s1 -e -m5000) test_input(train pds-20.mps pds-20.mps.out 0.02 0.0001 -s1 -e -m5000)
test_input(ref ref.mps ref.out 0.02 0.0001 -m3500) test_input(ref ref.mps ref.out 0.02 0.0001 -m3500)
test_input(ref pds-50.mps pds-50.mps.out 0.02 0.0001 -s1 -e -m45000) test_input(ref pds-50.mps pds-50.mps.out 0.02 0.0001 -s1 -e -m45000)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(450.soplex ${Source})
llvm_test_data_spec(450.soplex MUST_COPY data)
include(CopyDir)
macro(prepare_data run_type)
llvm_copy_dir(450.soplex
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${BENCHMARK_DIR}/data/${run_type}/input
)
endmacro()
prepare_data(test)
prepare_data(train)
prepare_data(ref)

test-suite/trunk/External/SPEC/CFP2006/453.povray/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(test_input run_type stdout_reltol) macro(test_input run_type stdout_reltol)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
SPEC-benchmark-${run_type}.ini
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
SPEC-benchmark-${run_type}.ini
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r ${stdout_reltol} ${FPCMP} -r ${stdout_reltol}
${BENCHMARK_DIR}/data/${run_type}/output/SPEC-benchmark.log data/${run_type}/output/SPEC-benchmark.log
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/SPEC-benchmark.log data/${run_type}/input/SPEC-benchmark.log
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/SPEC-benchmark.tga ${FPCMP}
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/SPEC-benchmark.tga data/${run_type}/output/SPEC-benchmark.tga
data/${run_type}/input/SPEC-benchmark.tga
) )
endmacro() endmacro()
test_input(test 0.0002) test_input(test 0.0002)
test_input(train 0.00005) test_input(train 0.00005)
test_input(ref 0.00005) test_input(ref 0.00005)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(453.povray ${Source})
llvm_test_data_spec(453.povray
data/test/output
data/train/output
data/ref/output
)
include(CopyDir)
llvm_copy_dir(453.povray ${CMAKE_CURRENT_BINARY_DIR}/data/test/input llvm_copy_dir(453.povray ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
${BENCHMARK_DIR}/data/test/input ${BENCHMARK_DIR}/data/test/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
) )
llvm_copy_dir(453.povray ${CMAKE_CURRENT_BINARY_DIR}/data/train/input llvm_copy_dir(453.povray ${CMAKE_CURRENT_BINARY_DIR}/data/train/input
${BENCHMARK_DIR}/data/train/input ${BENCHMARK_DIR}/data/train/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
) )
llvm_copy_dir(453.povray ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input llvm_copy_dir(453.povray ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
${BENCHMARK_DIR}/data/ref/input ${BENCHMARK_DIR}/data/ref/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
) )

test-suite/trunk/External/SPEC/CFP2006/470.lbm/CMakeLists.txt

include_directories(${BENCHMARK_DIR}/src) include_directories(${BENCHMARK_DIR}/src)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${ARGN} ${ARGN}
> ${CMAKE_CURRENT_BINARY_DIR}/lbm.out > ${CMAKE_CURRENT_BINARY_DIR}/lbm.out
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 0.0000001 ${FPCMP} -a 0.0000001
${BENCHMARK_DIR}/data/${run_type}/output/lbm.out data/${run_type}/output/lbm.out
${CMAKE_CURRENT_BINARY_DIR}/lbm.out lbm.out
) )
endmacro() endmacro()
test_input(test 20 reference.dat 0 1 100_100_130_cf_a.of) test_input(test 20 reference.dat 0 1 100_100_130_cf_a.of)
test_input(train 300 reference.dat 0 1 100_100_130_cf_b.of) test_input(train 300 reference.dat 0 1 100_100_130_cf_b.of)
test_input(ref 3000 reference.dat 0 0 100_100_130_ldc.of) test_input(ref 3000 reference.dat 0 0 100_100_130_ldc.of)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(470.lbm ${Source})
llvm_test_data_spec_default(470.lbm)

test-suite/trunk/External/SPEC/CFP2006/482.sphinx3/CMakeLists.txt

add_definitions(-DHAVE_CONFIG_H) add_definitions(-DHAVE_CONFIG_H)
include_directories(${BENCHMARK_DIR}/src ${BENCHMARK_DIR}/src/libutil) include_directories(${BENCHMARK_DIR}/src ${BENCHMARK_DIR}/src/libutil)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CFLAGS -fsigned-char) list(APPEND CFLAGS -fsigned-char)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
ctlfile . args.an4 ctlfile . args.an4
> ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/an4.log > ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/an4.log
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r .0004 ${FPCMP} -r .0004
${BENCHMARK_DIR}/data/${run_type}/output/considered.out data/${run_type}/output/considered.out
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/considered.out data/${run_type}/input/considered.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 1e-6 ${FPCMP} -r 1e-6
${BENCHMARK_DIR}/data/${run_type}/output/total_considered.out data/${run_type}/output/total_considered.out
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/total_considered.out data/${run_type}/input/total_considered.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r .001 ${FPCMP} -r .001
${BENCHMARK_DIR}/data/${run_type}/output/an4.log data/${run_type}/output/an4.log
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/an4.log data/${run_type}/input/an4.log
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
# The benchmark includes the filenames of the .c files in its output and we # The benchmark includes the filenames of the .c files in its output and we
# cannot have full paths in there so hack around... # cannot have full paths in there so hack around...
foreach(s ${Source}) foreach(s ${Source})
get_filename_component(basename ${s} NAME) get_filename_component(basename ${s} NAME)
set_source_files_properties(${s} PROPERTIES COMPILE_DEFINITIONS __FILE__="${basename}") set_source_files_properties(${s} PROPERTIES COMPILE_DEFINITIONS __FILE__="${basename}")
endforeach() endforeach()
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(482.sphinx3 ${Source})
include(CopyDir)
macro(prepare_data run_type) macro(prepare_data run_type)
set(DESTDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input) set(DESTDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input)
llvm_copy_dir(${PROG} ${DESTDIR}/model llvm_copy_dir(482.sphinx3 ${DESTDIR}/model
${BENCHMARK_DIR}/data/all/input/model ${BENCHMARK_DIR}/data/all/input/model
) )
llvm_copy(${PROG} ${DESTDIR} ${BENCHMARK_DIR}/data/${run_type}/input/args.an4) llvm_copy(482.sphinx3 ${DESTDIR} ${BENCHMARK_DIR}/data/${run_type}/input/args.an4)
llvm_copy(${PROG} ${DESTDIR} ${BENCHMARK_DIR}/data/${run_type}/input/beams.dat) llvm_copy(482.sphinx3 ${DESTDIR} ${BENCHMARK_DIR}/data/${run_type}/input/beams.dat)
# Create ctlfile and copy .raw files depending on endianess # Create ctlfile and copy .raw files depending on endianess
if(IS_BIGENDIAN) if(IS_BIGENDIAN)
file(GLOB files "${BENCHMARK_DIR}/data/${run_type}/input/*.be.raw") file(GLOB files "${BENCHMARK_DIR}/data/${run_type}/input/*.be.raw")
else() else()
file(GLOB files "${BENCHMARK_DIR}/data/${run_type}/input/*.le.raw") file(GLOB files "${BENCHMARK_DIR}/data/${run_type}/input/*.le.raw")
endif() endif()
list(SORT files) list(SORT files)
set(CTLFILE "") set(CTLFILE "")
foreach(f ${files}) foreach(f ${files})
get_filename_component(basename ${f} NAME) get_filename_component(basename ${f} NAME)
string(REGEX REPLACE ".(be|le).raw$" "" basename "${basename}") string(REGEX REPLACE ".(be|le).raw$" "" basename "${basename}")
llvm_copy(${PROG} ${DESTDIR}/${basename}.raw ${f}) llvm_copy(482.sphinx3 ${DESTDIR}/${basename}.raw ${f})
# Determine file size... # Determine file size...
file(READ ${f} content HEX) file(READ ${f} content HEX)
string(LENGTH ${content} content_length) string(LENGTH ${content} content_length)
math(EXPR filesize "${content_length} / 2") math(EXPR filesize "${content_length} / 2")
# Append line to ctlfile # Append line to ctlfile
set(CTLFILE "${CTLFILE}${basename} ${filesize}\n") set(CTLFILE "${CTLFILE}${basename} ${filesize}\n")
endforeach() endforeach()
file(GENERATE OUTPUT ${DESTDIR}/ctlfile CONTENT "${CTLFILE}") file(GENERATE OUTPUT ${DESTDIR}/ctlfile CONTENT "${CTLFILE}")
endmacro() endmacro()
prepare_data(test) prepare_data(test)
prepare_data(train) prepare_data(train)
prepare_data(ref) prepare_data(ref)
llvm_test_data_spec(482.sphinx3 MUST_COPY
data/test/output
data/train/output
data/ref/output
)
# Data comes with *.test files which should not be read by lit. # Data comes with *.test files which should not be read by lit.
file(GENERATE file(GENERATE
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/data/lit.local.cfg OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/data/lit.local.cfg
CONTENT "config.suffixes = []" CONTENT "config.suffixes = []"
) )

test-suite/trunk/External/SPEC/CINT2000/164.gzip/CMakeLists.txt

macro(test_input run_type filename size) macro(test_input run_type filename size)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/input/${filename} data/${run_type}/input/${filename} ${size} > ${filename}.out
${size}
> ${CMAKE_CURRENT_BINARY_DIR}/${filename}.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${filename}.out ${FPCMP} data/${run_type}/output/${filename}.out ${filename}.out
${CMAKE_CURRENT_BINARY_DIR}/${filename}.out
) )
endmacro() endmacro()
test_input(train input.combined 32) test_input(train input.combined 32)
test_input(test input.compressed 2) test_input(test input.compressed 2)
test_input(ref input.source 60) test_input(ref input.source 60)
test_input(ref input.log 60) test_input(ref input.log 60)
test_input(ref input.graphic 60) test_input(ref input.graphic 60)
test_input(ref input.random 60) test_input(ref input.random 60)
test_input(ref input.program 60) test_input(ref input.program 60)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(164.gzip ${Source})
llvm_test_data_spec_default(164.gzip)

test-suite/trunk/External/SPEC/CINT2000/175.vpr/CMakeLists.txt

list(APPEND CPPFLAGS -DNO_GRAPHICSS) list(APPEND CPPFLAGS -DNO_GRAPHICSS)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(test_input run_type costs_tolerance) macro(test_input run_type costs_tolerance)
set(COSTS_OUT ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/costs.out)
# The benchmark keeps appending to costs.out, so we have to make sure there # The benchmark keeps appending to costs.out, so we have to make sure there
# is none from previous runs # is none from previous runs
llvm_test_prepare(RUN_TYPE ${run_type} rm -f ${COSTS_OUT}) llvm_test_prepare(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
rm -f data/${run_type}/input/costs.out
)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
net.in arch.in place.out dum.out net.in arch.in place.out dum.out
-nodisp -place_only -init_t 5 -exit_t 0.005 -alpha_t 0.9412 -inner_num 2 -nodisp -place_only -init_t 5 -exit_t 0.005 -alpha_t 0.9412 -inner_num 2
> ${CMAKE_CURRENT_BINARY_DIR}/place_log.out > ${CMAKE_CURRENT_BINARY_DIR}/place_log.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/place_log.out ${FPCMP} data/${run_type}/output/place_log.out place_log.out
${CMAKE_CURRENT_BINARY_DIR}/place_log.out
) )
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
net.in arch.in place.in route.out net.in arch.in place.in route.out
-nodisp -route_only -route_chan_width 15 -pres_fac_mult 2 -acc_fac 1 -first_iter_pres_fac 4 -initial_pres_fac 8 -nodisp -route_only -route_chan_width 15 -pres_fac_mult 2 -acc_fac 1 -first_iter_pres_fac 4 -initial_pres_fac 8
> ${CMAKE_CURRENT_BINARY_DIR}/route_log.out > ${CMAKE_CURRENT_BINARY_DIR}/route_log.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.015 ${FPCMP} -r 0.015 data/${run_type}/output/route_log.out route_log.out
${BENCHMARK_DIR}/data/${run_type}/output/route_log.out )
${CMAKE_CURRENT_BINARY_DIR}/route_log.out llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) ${FPCMP} -r 0.015
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} data/${run_type}/output/route.out
-r 0.015 data/${run_type}/input/route.out
${BENCHMARK_DIR}/data/${run_type}/output/route.out )
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/route.out llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) ${FPCMP} -r ${costs_tolerance}
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} data/${run_type}/output/costs.out
-r ${costs_tolerance} data/${run_type}/input/costs.out
${BENCHMARK_DIR}/data/${run_type}/output/costs.out
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/costs.out
) )
endmacro() endmacro()
test_input(ref 0.05) test_input(ref 0.05)
test_input(train 0.05) test_input(train 0.05)
test_input(test 0.10) test_input(test 0.10)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(175.vpr ${Source})
llvm_test_data_spec(175.vpr MUST_COPY data)
# The benchmark writes the output where the input files are, so we have to
# copy the data over.
include(CopyDir)
llvm_copy_dir(175.vpr ${CMAKE_CURRENT_BINARY_DIR}/data ${BENCHMARK_DIR}/data)

test-suite/trunk/External/SPEC/CINT2000/176.gcc/CMakeLists.txt

if(ENDIAN STREQUAL "big") if(ENDIAN STREQUAL "big")
list(APPEND CPPFLAGS -DHOST_WORDS_BIG_ENDIAN) list(APPEND CPPFLAGS -DHOST_WORDS_BIG_ENDIAN)
endif() endif()
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
# Necessary for iOS # Necessary for iOS
list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x800000) list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x800000)
endif() endif()
list(APPEND CFLAGS -std=gnu89) list(APPEND CFLAGS -std=gnu89)
# We want reproducible builds # We want reproducible builds
list(APPEND CPPFLAGS -D__DATE__="XXX" -D__TIME__="XXX") list(APPEND CPPFLAGS -D__DATE__="XXX" -D__TIME__="XXX")
macro(test_input run_type ifile sfile) macro(test_input run_type ifile sfile)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/input/${ifile} data/${run_type}/input/${ifile} -o ${sfile}
-o ${CMAKE_CURRENT_BINARY_DIR}/${sfile}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${sfile} ${FPCMP} data/${run_type}/output/${sfile} ${sfile}
${CMAKE_CURRENT_BINARY_DIR}/${sfile}
) )
endmacro() endmacro()
test_input(ref 166.i 166.s) test_input(ref 166.i 166.s)
test_input(ref 200.i 200.s) test_input(ref 200.i 200.s)
test_input(ref expr.i expr.s) test_input(ref expr.i expr.s)
test_input(ref integrate.i integrate.s) test_input(ref integrate.i integrate.s)
test_input(ref scilab.i scilab.s) test_input(ref scilab.i scilab.s)
test_input(train cp-decl.i cp-decl.s) test_input(train cp-decl.i cp-decl.s)
test_input(test cccp.i cccp.s) test_input(test cccp.i cccp.s)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(176.gcc ${Source})
llvm_test_data_spec_default(176.gcc)

test-suite/trunk/External/SPEC/CINT2000/181.mcf/CMakeLists.txt

macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/input/inp.in data/${run_type}/input/inp.in > inp.out
> ${CMAKE_CURRENT_BINARY_DIR}/inp.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/mcf.out ${FPCMP} data/${run_type}/output/mcf.out mcf.out
${CMAKE_CURRENT_BINARY_DIR}/mcf.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/inp.out ${FPCMP} data/${run_type}/output/inp.out inp.out
${CMAKE_CURRENT_BINARY_DIR}/inp.out
) )
endmacro() endmacro()
test_input(ref) test_input(ref)
test_input(train) test_input(train)
test_input(test) test_input(test)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(181.mcf ${Source})
llvm_test_data_spec_default(181.mcf)

test-suite/trunk/External/SPEC/CINT2000/186.crafty/CMakeLists.txt

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesset(SourceNames
validate.c validate.c
) )
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
< ${BENCHMARK_DIR}/data/${run_type}/input/crafty.in < data/${run_type}/input/crafty.in > crafty.out
> ${CMAKE_CURRENT_BINARY_DIR}/crafty.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/crafty.out ${FPCMP} data/${run_type}/output/crafty.out crafty.out
${CMAKE_CURRENT_BINARY_DIR}/crafty.out
) )
endmacro() endmacro()
test_input(ref) test_input(ref)
test_input(train) test_input(train)
test_input(test) test_input(test)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(186.crafty ${Source})
llvm_test_data_spec_default(186.crafty)

test-suite/trunk/External/SPEC/CINT2000/197.parser/CMakeLists.txt

if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
list(APPEND CPPFLAGS -D_ANSI_SOURCE=1) list(APPEND CPPFLAGS -D_ANSI_SOURCE=1)
endif() endif()
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
2.1.dict -batch 2.1.dict -batch
< ${BENCHMARK_DIR}/data/${run_type}/input/${run_type}.in < ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${run_type}.in
> ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out > ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${run_type}.out ${FPCMP} data/${run_type}/output/${run_type}.out ${run_type}.out
${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
endmacro() endmacro()
test_input(ref) test_input(ref)
test_input(train) test_input(train)
test_input(test) test_input(test)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(197.parser ${Source})
llvm_test_data_spec_default(197.parser)

test-suite/trunk/External/SPEC/CINT2000/252.eon/CMakeLists.txt

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Linesset(SourceNames
myrand.cc myrand.cc
) )
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type) macro(test_input run_type)
set(INPUT_DIR ${BENCHMARK_DIR}/data/${run_type}/input) set(INPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input)
llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${INPUT_DIR} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${INPUT_DIR}
chair.control.cook chair.camera chair.surfaces chair.control.cook chair.camera chair.surfaces
${CMAKE_CURRENT_BINARY_DIR}/chair.cook.ppm ${CMAKE_CURRENT_BINARY_DIR}/chair.cook.ppm
ppm ppm
${CMAKE_CURRENT_BINARY_DIR}/pixels_out.cook ${CMAKE_CURRENT_BINARY_DIR}/pixels_out.cook
) )
llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${INPUT_DIR} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${INPUT_DIR}
chair.control.rushmeier chair.camera chair.surfaces chair.control.rushmeier chair.camera chair.surfaces
${CMAKE_CURRENT_BINARY_DIR}/chair.rushmeier.ppm ${CMAKE_CURRENT_BINARY_DIR}/chair.rushmeier.ppm
ppm ppm
${CMAKE_CURRENT_BINARY_DIR}/pixels_out.rushmeier ${CMAKE_CURRENT_BINARY_DIR}/pixels_out.rushmeier
) )
llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${INPUT_DIR} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${INPUT_DIR}
chair.control.kajiya chair.camera chair.surfaces chair.control.kajiya chair.camera chair.surfaces
${CMAKE_CURRENT_BINARY_DIR}/chair.kajiya.ppm ${CMAKE_CURRENT_BINARY_DIR}/chair.kajiya.ppm
ppm ppm
${CMAKE_CURRENT_BINARY_DIR}/pixels_out.kajiya ${CMAKE_CURRENT_BINARY_DIR}/pixels_out.kajiya
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 0.005 ${FPCMP} -a 0.005
${BENCHMARK_DIR}/data/${run_type}/output/pixels_out.cook data/${run_type}/output/pixels_out.cook
${CMAKE_CURRENT_BINARY_DIR}/pixels_out.cook pixels_out.cook
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 0.005 ${FPCMP} -a 0.005
${BENCHMARK_DIR}/data/${run_type}/output/pixels_out.rushmeier data/${run_type}/output/pixels_out.rushmeier
${CMAKE_CURRENT_BINARY_DIR}/pixels_out.rushmeier pixels_out.rushmeier
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-a 0.005 ${FPCMP} -a 0.005
${BENCHMARK_DIR}/data/${run_type}/output/pixels_out.kajiya data/${run_type}/output/pixels_out.kajiya
${CMAKE_CURRENT_BINARY_DIR}/pixels_out.kajiya pixels_out.kajiya
) )
endmacro() endmacro()
test_input(ref) test_input(ref)
test_input(train) test_input(train)
test_input(test) test_input(test)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(252.eon ${Source})
llvm_test_data_spec_default(252.eon)

test-suite/trunk/External/SPEC/CINT2000/253.perlbmk/CMakeLists.txt

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type perlscript output) macro(test_input run_type perlscript output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
-I${BENCHMARK_DIR}/data/all/input/lib ${perlscript} -I${CMAKE_CURRENT_BINARY_DIR}/data/all/input/lib ${perlscript}
> ${CMAKE_CURRENT_BINARY_DIR}/${output} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
${ARGN} ${ARGN}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
# (Parameters come from the respective XXX.in files) # (Parameters come from the respective XXX.in files)
test_input(train test_input(train
${BENCHMARK_DIR}/data/all/input/diffmail.pl diffmail.pl 2.350.15.24.23.150.out 2 350 15 24 23 150
2.350.15.24.23.150.out WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
2 350 15 24 23 150
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
test_input(train test_input(train
${BENCHMARK_DIR}/data/all/input/perfect.pl perfect.pl b.3.out b 3
b.3.out WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
b 3
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
test_input(train test_input(train
${BENCHMARK_DIR}/data/train/input/scrabbl.pl scrabbl.pl scrabbl.out < scrabbl.in
scrabbl.out WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/train/input
< ${BENCHMARK_DIR}/data/train/input/scrabbl.in
WORKDIR ${BENCHMARK_DIR}/data/train/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/ref/input/splitmail.pl splitmail.pl 850.5.19.18.1500.out 850 5 19 18 1500
850.5.19.18.1500.out
850 5 19 18 1500
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/ref/input/splitmail.pl splitmail.pl 704.12.26.16.836.out 704 12 26 16 836
704.12.26.16.836.out
704 12 26 16 836
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/ref/input/splitmail.pl splitmail.pl 535.13.25.24.1091.out 535 13 25 24 1091
535.13.25.24.1091.out
535 13 25 24 1091
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/ref/input/splitmail.pl splitmail.pl 957.12.23.26.1014.out 957 12 23 26 1014
957.12.23.26.1014.out
957 12 23 26 1014
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/all/input/diffmail.pl diffmail.pl 2.550.15.24.23.100.out 2 550 15 24 23 100
2.550.15.24.23.100.out WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
2 550 15 24 23 100
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/all/input/perfect.pl perfect.pl b.3.m.4.out b 3 m 4
b.3.m.4.out WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
b 3 m 4
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/ref/input/makerand.pl makerand.pl makerand.out
makerand.out WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
file(GLOB inputs ${BENCHMARK_DIR}/data/test/input/*.t) file(GLOB inputs ${BENCHMARK_DIR}/data/test/input/*.t)
foreach(input ${inputs}) foreach(input ${inputs})
get_filename_component(basename ${input} NAME_WE) get_filename_component(basename ${input} NAME_WE)
test_input(test test_input(test
${CMAKE_CURRENT_BINARY_DIR}/data/test/input/${basename}.t ${basename}.t ${basename}.out
${basename}.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/test/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
) )
endforeach() endforeach()
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(253.perlbmk ${Source})
llvm_test_data_spec(253.perlbmk MUST_COPY
data/test/output
data/train/input
data/train/output
data/ref/output
data/all/input
)
include(CopyDir) llvm_copy_dir(253.perlbmk ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
llvm_copy_dir(${PROG} ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
${BENCHMARK_DIR}/data/test/input ${BENCHMARK_DIR}/data/test/input
) )
llvm_copy_dir(${PROG} ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input llvm_copy_dir(253.perlbmk ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
${BENCHMARK_DIR}/data/ref/input ${BENCHMARK_DIR}/data/ref/input
) )

test-suite/trunk/External/SPEC/CINT2000/254.gap/CMakeLists.txt

# We need to include unistd.h because something with Fedora Core 1 is broken, # We need to include unistd.h because something with Fedora Core 1 is broken,
# and we need the sysconf() macros. # and we need the sysconf() macros.
list(APPEND CPPFLAGS -include unistd.h -DSYS_HAS_CALLOC_PROTO -DSYS_HAS_IOCTL_PROTO -DSYS_HAS_TIME_PROTO -DSYS_HAS_READ_PROTO) list(APPEND CPPFLAGS -include unistd.h -DSYS_HAS_CALLOC_PROTO -DSYS_HAS_IOCTL_PROTO -DSYS_HAS_TIME_PROTO -DSYS_HAS_READ_PROTO)
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
list(APPEND CPPFLAGS -DSYS_IS_BSD) list(APPEND CPPFLAGS -DSYS_IS_BSD)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/stubs) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/stubs)
else() else()
list(APPEND CPPFLAGS -DSYS_IS_USG) list(APPEND CPPFLAGS -DSYS_IS_USG)
endif() endif()
# 254.gap relies on signed arithmetic overflow being well-defined. # 254.gap relies on signed arithmetic overflow being well-defined.
LIST(APPEND CFLAGS -fwrapv) LIST(APPEND CFLAGS -fwrapv)
macro(test_input run_type heapsize) macro(test_input run_type heapsize)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-l ${BENCHMARK_DIR}/data/all/input -q -m ${heapsize} -l data/all/input -q -m ${heapsize}
< ${BENCHMARK_DIR}/data/${run_type}/input/${run_type}.in < data/${run_type}/input/${run_type}.in
> ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out > ${run_type}.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.01 ${FPCMP} -r 0.01 data/${run_type}/output/${run_type}.out ${run_type}.out
${BENCHMARK_DIR}/data/${run_type}/output/${run_type}.out
${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
endmacro() endmacro()
test_input(ref 192M) test_input(ref 192M)
test_input(train 128M) test_input(train 128M)
test_input(test 64M) test_input(test 64M)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(254.gap ${Source})
llvm_test_data_spec_default(254.gap)

test-suite/trunk/External/SPEC/CINT2000/255.vortex/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(test_input run_type input outfile) macro(test_input run_type input outfile)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${input} ${input}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${outfile} ${FPCMP}
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${outfile} data/${run_type}/output/${outfile}
data/${run_type}/input/${outfile}
) )
endmacro() endmacro()
include(TestBigEndian) include(TestBigEndian)
test_big_endian(IS_BIGENDIAN) test_big_endian(IS_BIGENDIAN)
if(IS_BIGENDIAN) if(IS_BIGENDIAN)
set(endianname "bendian") set(endianname "bendian")
else() else()
set(endianname "lendian") set(endianname "lendian")
endif() endif()
test_input(test ${endianname}.raw vortex.out) test_input(test ${endianname}.raw vortex.out)
test_input(train ${endianname}.raw vortex.out) test_input(train ${endianname}.raw vortex.out)
test_input(ref ${endianname}1.raw vortex1.out) test_input(ref ${endianname}1.raw vortex1.out)
test_input(ref ${endianname}2.raw vortex2.out) test_input(ref ${endianname}2.raw vortex2.out)
test_input(ref ${endianname}3.raw vortex3.out) test_input(ref ${endianname}3.raw vortex3.out)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(255.vortex ${Source})
llvm_test_data_spec(255.vortex MUST_COPY data)
# The benchmark writes the output where the input files are, so we have to
# copy the data over.
include(CopyDir)
llvm_copy_dir(${PROG} ${CMAKE_CURRENT_BINARY_DIR}/data ${BENCHMARK_DIR}/data)

test-suite/trunk/External/SPEC/CINT2000/256.bzip2/CMakeLists.txt

macro(test_input run_type filename size) macro(test_input run_type filename size)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
${BENCHMARK_DIR}/data/${run_type}/input/${filename} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${size} data/${run_type}/input/${filename} ${size} > ${filename}.out
> ${CMAKE_CURRENT_BINARY_DIR}/${filename}.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${filename}.out ${FPCMP} data/${run_type}/output/${filename}.out ${filename}.out
${CMAKE_CURRENT_BINARY_DIR}/${filename}.out
) )
endmacro() endmacro()
test_input(train input.compressed 8) test_input(train input.compressed 8)
test_input(test input.random 2) test_input(test input.random 2)
test_input(ref input.source 58) test_input(ref input.source 58)
test_input(ref input.graphic 58) test_input(ref input.graphic 58)
test_input(ref input.program 58) test_input(ref input.program 58)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(256.bzip2 ${Source})
llvm_test_data_spec_default(256.bzip2)

test-suite/trunk/External/SPEC/CINT2000/300.twolf/CMakeLists.txt

list(APPEND CPPFLAGS -DHAVE_SIGNED_CHAR) list(APPEND CPPFLAGS -DHAVE_SIGNED_CHAR)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CFLAGS -Wno-return-type) list(APPEND CFLAGS -Wno-return-type)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${run_type} ${run_type} > ${run_type}.stdout
> ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${run_type}.stdout
) )
foreach(file IN ITEMS ${run_type}.twf ${run_type}.pl2 ${run_type}.sav ${run_type}.pl1 ${run_type}.pl1 ${run_type}.pin ${run_type}.stdout ${run_type}.sv2 ${run_type}.out) foreach(file IN ITEMS ${run_type}.twf ${run_type}.pl2 ${run_type}.sav ${run_type}.pl1 ${run_type}.pl1 ${run_type}.pin ${run_type}.stdout ${run_type}.sv2 ${run_type}.out)
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${file} ${FPCMP} data/${run_type}/output/${file} data/${run_type}/input/${file}
${BENCHMARK_DIR}/data/${run_type}/output/${file}
) )
endforeach() endforeach()
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(300.twolf ${Source})
llvm_test_data_spec(300.twolf MUST_COPY data)
# The benchmark writes the output where the input files are, so we have to
# copy the data over.
include(CopyDir)
llvm_copy_dir(${PROG} ${CMAKE_CURRENT_BINARY_DIR}/data ${BENCHMARK_DIR}/data)

test-suite/trunk/External/SPEC/CINT2000/CMakeLists.txt

include(${CMAKE_SOURCE_DIR}/External/SPEC/SpecCPU2000.cmake) include(${CMAKE_SOURCE_DIR}/External/SPEC/SpecCPU2000.cmake)
if(TEST_SUITE_SPEC2000_ROOT) if(TEST_SUITE_SPEC2000_ROOT)
macro(cint2000_subdir BENCHMARK) macro(cint2000_subdir BENCHMARK)
set(BENCHMARK_DIR ${TEST_SUITE_SPEC2000_ROOT}/benchspec/CINT2000/${BENCHMARK}) set(BENCHMARK_DIR ${TEST_SUITE_SPEC2000_ROOT}/benchspec/CINT2000/${BENCHMARK})
set(PROG ${BENCHMARK})
file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp) file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp)
add_subdirectory(${BENCHMARK}) add_subdirectory(${BENCHMARK})
endmacro() endmacro()
cint2000_subdir(164.gzip) cint2000_subdir(164.gzip)
cint2000_subdir(175.vpr) cint2000_subdir(175.vpr)
cint2000_subdir(176.gcc) cint2000_subdir(176.gcc)
cint2000_subdir(181.mcf) cint2000_subdir(181.mcf)
Show All 9 Lines

test-suite/trunk/External/SPEC/CINT2006/400.perlbench/CMakeLists.txt

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
endforeach() endforeach()
macro(test_input run_type perlscript output) macro(test_input run_type perlscript output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
-I${CMAKE_CURRENT_BINARY_DIR}/data/all/input/lib ${perlscript} -I${CMAKE_CURRENT_BINARY_DIR}/data/all/input/lib ${perlscript}
> ${CMAKE_CURRENT_BINARY_DIR}/${output} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
${ARGN} ${ARGN}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
# (Parameters come from the respective XXX.in files) # (Parameters come from the respective XXX.in files)
test_input(train test_input(train
${BENCHMARK_DIR}/data/all/input/diffmail.pl diffmail.pl diffmail.2.550.15.24.23.100.out 2 550 15 24 23 100
diffmail.2.550.15.24.23.100.out
2 550 15 24 23 100
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
) )
test_input(train test_input(train
${BENCHMARK_DIR}/data/train/input/perfect.pl perfect.pl perfect.b.3.out b 3
perfect.b.3.out
b 3
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/train/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/train/input
) )
test_input(train test_input(train
${BENCHMARK_DIR}/data/all/input/splitmail.pl splitmail.pl splitmail.535.13.25.24.1091.out 535 13 25 24 1091
splitmail.535.13.25.24.1091.out
535 13 25 24 1091
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
) )
test_input(train test_input(train
${BENCHMARK_DIR}/data/train/input/suns.pl suns.pl suns.out
suns.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/train/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/train/input
) )
llvm_test_verify(RUN_TYPE train ${FPCMP} llvm_test_verify(RUN_TYPE train WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/train/output/validate ${FPCMP} data/train/output/validate data/train/input/validate
${CMAKE_CURRENT_BINARY_DIR}/data/train/input/validate
) )
#test_input(train scrabbl.pl scrabbl.in) # spec doesn't come with output files? #test_input(train scrabbl.pl scrabbl.in) # spec doesn't come with output files?
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/all/input/diffmail.pl diffmail.pl diffmail.4.800.10.17.19.300.out 4 800 10 17 19 300
diffmail.4.800.10.17.19.300.out
4 800 10 17 19 300
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/all/input/splitmail.pl splitmail.pl splitmail.1600.12.26.16.4500.out 1600 12 26 16 4500
splitmail.1600.12.26.16.4500.out
1600 12 26 16 4500
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
) )
test_input(ref test_input(ref
${BENCHMARK_DIR}/data/ref/input/checkspam.pl ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input/checkspam.pl
checkspam.2500.5.25.11.150.1.1.1.1.out checkspam.2500.5.25.11.150.1.1.1.1.out
2500 5 25 11 150 1 1 1 1 2500 5 25 11 150 1 1 1 1
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
) )
file(GLOB inputs ${BENCHMARK_DIR}/data/test/input/*.t) file(GLOB inputs ${BENCHMARK_DIR}/data/test/input/*.t)
foreach(input ${inputs}) foreach(input ${inputs})
get_filename_component(basename ${input} NAME_WE) get_filename_component(basename ${input} NAME_WE)
test_input(test test_input(test
${CMAKE_CURRENT_BINARY_DIR}/data/test/input/${basename}.t ${basename}.t ${basename}.out
${basename}.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/test/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
) )
endforeach() endforeach()
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(400.perlbench ${Source})
llvm_test_data_spec(400.perlbench MUST_COPY data)
include(CopyDir)
llvm_copy_dir(${PROG} ${CMAKE_CURRENT_BINARY_DIR}/data ${BENCHMARK_DIR}/data)

test-suite/trunk/External/SPEC/CINT2006/401.bzip2/CMakeLists.txt

macro(test_input run_type input size output) macro(test_input run_type input size output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${input} ${input} ${size} > ${output}
${size}
> ${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test ${BENCHMARK_DIR}/data/all/input/input.program 5 input.program.out) test_input(test data/all/input/input.program 5 input.program.out)
test_input(test ${BENCHMARK_DIR}/data/test/input/dryer.jpg 2 dryer.jpg.out) test_input(test data/test/input/dryer.jpg 2 dryer.jpg.out)
test_input(train ${BENCHMARK_DIR}/data/all/input/input.program 10 input.program.out) test_input(train data/all/input/input.program 10 input.program.out)
test_input(train ${BENCHMARK_DIR}/data/train/input/byoudoin.jpg 5 byoudoin.jpg.out) test_input(train data/train/input/byoudoin.jpg 5 byoudoin.jpg.out)
test_input(train ${BENCHMARK_DIR}/data/all/input/input.combined 80 input.combined.out) test_input(train data/all/input/input.combined 80 input.combined.out)
test_input(ref ${BENCHMARK_DIR}/data/ref/input/input.source 280 input.source.out) test_input(ref data/ref/input/input.source 280 input.source.out)
test_input(ref ${BENCHMARK_DIR}/data/ref/input/chicken.jpg 30 chicken.jpg.out) test_input(ref data/ref/input/chicken.jpg 30 chicken.jpg.out)
test_input(ref ${BENCHMARK_DIR}/data/ref/input/liberty.jpg 30 liberty.jpg.out) test_input(ref data/ref/input/liberty.jpg 30 liberty.jpg.out)
test_input(ref ${BENCHMARK_DIR}/data/all/input/input.program 280 input.program.out) test_input(ref data/all/input/input.program 280 input.program.out)
test_input(ref ${BENCHMARK_DIR}/data/ref/input/text.html 280 text.html.out) test_input(ref data/ref/input/text.html 280 text.html.out)
test_input(ref ${BENCHMARK_DIR}/data/all/input/input.combined 200 input.combined.out) test_input(ref data/all/input/input.combined 200 input.combined.out)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(401.bzip2 ${Source})
llvm_test_data_spec_default(401.bzip2)

test-suite/trunk/External/SPEC/CINT2006/403.gcc/CMakeLists.txt

include_directories(${BENCHMARK_DIR}/src) include_directories(${BENCHMARK_DIR}/src)
include(TestBigEndian) include(TestBigEndian)
if(IS_BIGENDIAN) if(IS_BIGENDIAN)
list(APPEND CPPFLAGS -DHOST_WORDS_BIG_ENDIAN) list(APPEND CPPFLAGS -DHOST_WORDS_BIG_ENDIAN)
endif() endif()
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
# Necessary for iOS # Necessary for iOS
list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x8000000) list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x8000000)
endif() endif()
list(APPEND CPPFLAGS -DPOSIX -DSPEC_CPU_HAVE_BOOL) list(APPEND CPPFLAGS -DPOSIX -DSPEC_CPU_HAVE_BOOL)
macro(test_input run_type ifile sfile) macro(test_input run_type ifile sfile)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/input/${ifile} data/${run_type}/input/${ifile} -o ${sfile}
-o ${CMAKE_CURRENT_BINARY_DIR}/${sfile}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${sfile} ${FPCMP} data/${run_type}/output/${sfile} ${sfile}
${CMAKE_CURRENT_BINARY_DIR}/${sfile}
) )
endmacro() endmacro()
test_input(test cccp.in cccp.s) test_input(test cccp.in cccp.s)
test_input(train integrate.in integrate.s) test_input(train integrate.in integrate.s)
test_input(ref 166.in 166.s) test_input(ref 166.in 166.s)
test_input(ref 200.in 200.s) test_input(ref 200.in 200.s)
test_input(ref c-typeck.in c-typeck.s) test_input(ref c-typeck.in c-typeck.s)
test_input(ref cp-decl.in cp-decl.s) test_input(ref cp-decl.in cp-decl.s)
test_input(ref expr.in expr.s) test_input(ref expr.in expr.s)
test_input(ref expr2.in expr2.s) test_input(ref expr2.in expr2.s)
test_input(ref g23.in g23.s) test_input(ref g23.in g23.s)
test_input(ref s04.in s04.s) test_input(ref s04.in s04.s)
test_input(ref scilab.in scilab.s) test_input(ref scilab.in scilab.s)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(403.gcc ${Source})
llvm_test_data_spec_default(403.gcc)

test-suite/trunk/External/SPEC/CINT2006/429.mcf/CMakeLists.txt

list(APPEND CPPFLAGS -DWANT_STDC_PROTO) list(APPEND CPPFLAGS -DWANT_STDC_PROTO)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/input/inp.in data/${run_type}/input/inp.in > inp.out
> ${CMAKE_CURRENT_BINARY_DIR}/inp.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/inp.out ${FPCMP} data/${run_type}/output/inp.out inp.out
${CMAKE_CURRENT_BINARY_DIR}/inp.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/mcf.out ${FPCMP} data/${run_type}/output/mcf.out mcf.out
${CMAKE_CURRENT_BINARY_DIR}/mcf.out
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(429.mcf ${Source})
llvm_test_data_spec_default(429.mcf)

test-suite/trunk/External/SPEC/CINT2006/445.gobmk/CMakeLists.txt

list(APPEND CPPFLAGS -DWANT_STDC_PROTO) list(APPEND CPPFLAGS -DWANT_STDC_PROTO)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(Source "") set(Source "")
foreach(dir IN ITEMS foreach(dir IN ITEMS
src/sgf src/engine src/interface src/patterns src/utils src) src/sgf src/engine src/interface src/patterns src/utils src)
include_directories(${BENCHMARK_DIR}/${dir}) include_directories(${BENCHMARK_DIR}/${dir})
file(GLOB MoreSource ${BENCHMARK_DIR}/${dir}/*.c) file(GLOB MoreSource ${BENCHMARK_DIR}/${dir}/*.c)
list(APPEND Source ${MoreSource}) list(APPEND Source ${MoreSource})
endforeach() endforeach()
include_directories(${BENCHMARK_DIR}/src/include) include_directories(${BENCHMARK_DIR}/src/include)
macro(test_input run_type tstfile outfile) macro(test_input run_type tstfile outfile)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/all/input
--quiet --mode gtp --quiet --mode gtp
< ${BENCHMARK_DIR}/data/${run_type}/input/${tstfile} < ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${tstfile}
> ${CMAKE_CURRENT_BINARY_DIR}/${outfile} > ${CMAKE_CURRENT_BINARY_DIR}/${outfile}
WORKDIR ${BENCHMARK_DIR}/data/all/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${outfile} ${FPCMP} data/${run_type}/output/${outfile} ${outfile}
${CMAKE_CURRENT_BINARY_DIR}/${outfile}
) )
endmacro() endmacro()
foreach(tstfile IN ITEMS foreach(tstfile IN ITEMS
capture.tst connect_rot.tst connection_rot.tst dniwog.tst connect.tst capture.tst connect_rot.tst connection_rot.tst dniwog.tst connect.tst
connection.tst cutstone.tst) connection.tst cutstone.tst)
get_filename_component(basename ${tstfile} NAME_WE) get_filename_component(basename ${tstfile} NAME_WE)
test_input(test ${tstfile} ${basename}.out) test_input(test ${tstfile} ${basename}.out)
endforeach() endforeach()
foreach(tstfile IN ITEMS foreach(tstfile IN ITEMS
arb.tst arion.tst blunder.tst nicklas2.tst arend.tst atari_atari.tst arb.tst arion.tst blunder.tst nicklas2.tst arend.tst atari_atari.tst
buzco.tst nicklas4.tst) buzco.tst nicklas4.tst)
get_filename_component(basename ${tstfile} NAME_WE) get_filename_component(basename ${tstfile} NAME_WE)
test_input(train ${tstfile} ${basename}.out) test_input(train ${tstfile} ${basename}.out)
endforeach() endforeach()
foreach(tstfile IN ITEMS foreach(tstfile IN ITEMS
13x13.tst nngs.tst score2.tst trevorc.tst trevord.tst) 13x13.tst nngs.tst score2.tst trevorc.tst trevord.tst)
get_filename_component(basename ${tstfile} NAME_WE) get_filename_component(basename ${tstfile} NAME_WE)
test_input(ref ${tstfile} ${basename}.out) test_input(ref ${tstfile} ${basename}.out)
endforeach() endforeach()
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(445.gobmk ${Source})
llvm_test_data_spec_default(445.gobmk)

test-suite/trunk/External/SPEC/CINT2006/456.hmmer/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(test_input run_type input output) macro(test_input run_type input output)
# The benchmark modifies the data file, need to copy a fresh one # The benchmark modifies the data file, need to copy a fresh one
llvm_test_prepare(RUN_TYPE ${run_type} llvm_test_prepare(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
cp -f cp -f data/${run_type}/input/${input} ${input}
${BENCHMARK_DIR}/data/${run_type}/input/${input} )
${CMAKE_CURRENT_BINARY_DIR}/${input} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) ${ARGN} ${input} > ${output}
llvm_test_run(RUN_TYPE ${run_type} )
${ARGN} ${input} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
> ${CMAKE_CURRENT_BINARY_DIR}/${output} ${FPCMP} -r 0.002 -a 0.00001 data/${run_type}/output/${output} ${output}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
)
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP}
-r 0.002 -a 0.00001
${BENCHMARK_DIR}/data/${run_type}/output/${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test bombesin.hmm bombesin.out test_input(test bombesin.hmm bombesin.out
--fixed 0 --mean 325 --num 45000 --sd 200 --seed 0 --fixed 0 --mean 325 --num 45000 --sd 200 --seed 0
) )
test_input(train leng100.hmm leng100.out test_input(train leng100.hmm leng100.out
--fixed 0 --mean 425 --num 85000 --sd 300 --seed 0 --fixed 0 --mean 425 --num 85000 --sd 300 --seed 0
) )
# Copy nph3.hmm as well # Copy nph3.hmm as well
llvm_test_prepare(RUN_TYPE ref llvm_test_prepare(RUN_TYPE ref WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
cp -f cp -f data/ref/input/nph3.hmm nph3.hmm
${BENCHMARK_DIR}/data/ref/input/nph3.hmm
${CMAKE_CURRENT_BINARY_DIR}/nph3.hmm
) )
test_input(ref swiss41 nph3.out test_input(ref swiss41 nph3.out
nph3.hmm nph3.hmm
) )
test_input(ref retro.hmm retro.out test_input(ref retro.hmm retro.out
--fixed 0 --mean 500 --num 500000 --sd 350 --seed 0 --fixed 0 --mean 500 --num 500000 --sd 350 --seed 0
) )
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(456.hmmer ${Source})
llvm_test_data_spec_default(456.hmmer)

test-suite/trunk/External/SPEC/CINT2006/458.sjeng/CMakeLists.txt

macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/input/${run_type}.txt data/${run_type}/input/${run_type}.txt > ${run_type}.out
> ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${run_type}.out ${FPCMP} data/${run_type}/output/${run_type}.out ${run_type}.out
${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(458.sjeng ${Source})
llvm_test_data_spec_default(458.sjeng)

test-suite/trunk/External/SPEC/CINT2006/462.libquantum/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${ARGN} ${ARGN} > ${run_type}.out
> ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
# Reference outputs for test+train have CRLF line endings so we have to use # Reference outputs for test+train have CRLF line endings so we have to use
# diff --strip-trailing-cr # diff --strip-trailing-cr
# (This flag is a gnu extension, maybe we should rather extend fpcmp or # (This flag is a gnu extension, maybe we should rather extend fpcmp or
# somehow copy+fix the reference outputs?) # somehow copy+fix the reference outputs?)
llvm_test_verify(RUN_TYPE ${run_type} diff llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
--strip-trailing-cr diff --strip-trailing-cr
${BENCHMARK_DIR}/data/${run_type}/output/${run_type}.out data/${run_type}/output/${run_type}.out
${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out ${run_type}.out
) )
endmacro() endmacro()
test_input(test 33 5) test_input(test 33 5)
test_input(train 143 25) test_input(train 143 25)
test_input(ref 1397 8) test_input(ref 1397 8)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(462.libquantum ${Source})
llvm_test_data_spec_default(462.libquantum)

test-suite/trunk/External/SPEC/CINT2006/464.h264ref/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CFLAGS -fsigned-char) list(APPEND CFLAGS -fsigned-char)
macro(test_input run_type leading level) macro(test_input run_type leading level)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
-d ${leading}encoder_${level}.cfg -d ${leading}encoder_${level}.cfg
> ${CMAKE_CURRENT_BINARY_DIR}/${leading}${level}_encodelog.out > ${CMAKE_CURRENT_BINARY_DIR}/${leading}${level}_encodelog.out
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${leading}${level}_encodelog.out ${FPCMP}
${CMAKE_CURRENT_BINARY_DIR}/${leading}${level}_encodelog.out data/${run_type}/output/${leading}${level}_encodelog.out
) ${leading}${level}_encodelog.out
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} )
${BENCHMARK_DIR}/data/${run_type}/output/${leading}${level}_leakybucketparam.cfg llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/${leading}${level}_leakybucketparam.cfg ${FPCMP}
data/${run_type}/output/${leading}${level}_leakybucketparam.cfg
data/${run_type}/input/${leading}${level}_leakybucketparam.cfg
) )
endmacro() endmacro()
test_input(test foreman_test_ baseline) test_input(test foreman_test_ baseline)
test_input(train foreman_train_ baseline) test_input(train foreman_train_ baseline)
test_input(ref foreman_ref_ baseline) test_input(ref foreman_ref_ baseline)
test_input(ref foreman_ref_ main) test_input(ref foreman_ref_ main)
test_input(ref sss_ main) test_input(ref sss_ main)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(464.h264ref ${Source})
llvm_test_data_spec(464.h264ref
data/test/output
data/train/output
data/ref/output
)
# TODO: This will copy a bit more than 50M of data, maybe we should symlink it? # TODO: This will copy a bit more than 50M of data, maybe we should symlink it?
include(CopyDir)
llvm_copy_dir(464.h264ref ${CMAKE_CURRENT_BINARY_DIR}/data/test/input llvm_copy_dir(464.h264ref ${CMAKE_CURRENT_BINARY_DIR}/data/test/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
${BENCHMARK_DIR}/data/test/input ${BENCHMARK_DIR}/data/test/input
) )
llvm_copy_dir(464.h264ref ${CMAKE_CURRENT_BINARY_DIR}/data/train/input llvm_copy_dir(464.h264ref ${CMAKE_CURRENT_BINARY_DIR}/data/train/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
${BENCHMARK_DIR}/data/train/input ${BENCHMARK_DIR}/data/train/input
) )
llvm_copy_dir(464.h264ref ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input llvm_copy_dir(464.h264ref ${CMAKE_CURRENT_BINARY_DIR}/data/ref/input
${BENCHMARK_DIR}/data/all/input ${BENCHMARK_DIR}/data/all/input
${BENCHMARK_DIR}/data/ref/input ${BENCHMARK_DIR}/data/ref/input
) )

test-suite/trunk/External/SPEC/CINT2006/471.omnetpp/CMakeLists.txt

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
) )
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
-f ${BENCHMARK_DIR}/data/${run_type}/input/omnetpp.ini -f data/${run_type}/input/omnetpp.ini
> ${CMAKE_CURRENT_BINARY_DIR}/omnetpp.log > omnetpp.log
WORKDIR ${CMAKE_CURRENT_BINARY_DIR} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.00001 -a 0.000001 ${FPCMP} -r 0.00001 -a 0.000001
${BENCHMARK_DIR}/data/${run_type}/output/omnetpp.log data/${run_type}/output/omnetpp.log
${CMAKE_CURRENT_BINARY_DIR}/omnetpp.log omnetpp.log
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.00001 -a 0.000001 ${FPCMP} -r 0.00001 -a 0.000001
${BENCHMARK_DIR}/data/${run_type}/output/omnetpp.sca data/${run_type}/output/omnetpp.sca
${CMAKE_CURRENT_BINARY_DIR}/omnetpp.sca omnetpp.sca
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(471.omnetpp ${Source})
llvm_test_data_spec_default(471.omnetpp)

test-suite/trunk/External/SPEC/CINT2006/473.astar/CMakeLists.txt

list(APPEND CPPFLAGS -std=c++98) list(APPEND CPPFLAGS -std=c++98)
macro(test_input run_type input output) macro(test_input run_type input output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
${input} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
> ${CMAKE_CURRENT_BINARY_DIR}/${output} ${input} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.001 ${FPCMP} -r 0.001 data/${run_type}/output/${output} ${output}
${BENCHMARK_DIR}/data/${run_type}/output/${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test lake.cfg lake.out) test_input(test lake.cfg lake.out)
test_input(train BigLakes1024.cfg BigLakes1024.out) test_input(train BigLakes1024.cfg BigLakes1024.out)
test_input(train rivers1.cfg rivers1.out) test_input(train rivers1.cfg rivers1.out)
test_input(ref BigLakes2048.cfg BigLakes2048.out) test_input(ref BigLakes2048.cfg BigLakes2048.out)
test_input(ref rivers.cfg rivers.out) test_input(ref rivers.cfg rivers.out)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(473.astar ${Source})
llvm_test_data_spec_default(473.astar)

test-suite/trunk/External/SPEC/CINT2006/483.xalancbmk/CMakeLists.txt

Show All 26 Lines
) )
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
# Necessary for iOS # Necessary for iOS
list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x8000000) list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x8000000)
endif() endif()
macro(test_input run_type input output) macro(test_input run_type input output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
-v ${input} xalanc.xsl -v ${input} xalanc.xsl
> ${CMAKE_CURRENT_BINARY_DIR}/${output} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-r 0.001 ${FPCMP} -r 0.001 data/${run_type}/output/${output} ${output}
${BENCHMARK_DIR}/data/${run_type}/output/${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test test.xml test.out) test_input(test test.xml test.out)
test_input(train allbooks.xml train.out) test_input(train allbooks.xml train.out)
test_input(ref t5.xml ref.out) test_input(ref t5.xml ref.out)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(483.xalancbmk ${Source})
llvm_test_data_spec_default(483.xalancbmk)

test-suite/trunk/External/SPEC/CINT95/099.go/CMakeLists.txt

macro(test_input run_type input output size0 size1) macro(test_input run_type input output size0 size1)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${size0} ${size1} ${input} ${size0} ${size1} ${input}
> ${CMAKE_CURRENT_BINARY_DIR}/${output} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test null.in null.out 40 19) test_input(test null.in null.out 40 19)
test_input(train 2stone9.in 2stone9.out 50 9) test_input(train 2stone9.in 2stone9.out 50 9)
test_input(ref 5stone21.in 5stone21.out 50 21) test_input(ref 5stone21.in 5stone21.out 50 21)
test_input(ref 9stone21.in 9stone21.out 50 21) test_input(ref 9stone21.in 9stone21.out 50 21)
test_input(ref null.in null.out 50 21) test_input(ref null.in null.out 50 21)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(099.go ${Source})
llvm_test_data_spec_default(099.go)

test-suite/trunk/External/SPEC/CINT95/124.m88ksim/CMakeLists.txt

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
) )
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
-c < ${BENCHMARK_DIR}/data/${run_type}/input/${CTLFILE} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
> ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out -c < ${CTLFILE} > ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${run_type}.out ${FPCMP} data/${run_type}/output/${run_type}.out ${run_type}.out
${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(124.m88ksim ${Source})
llvm_test_data_spec_default(124.m88ksim)

test-suite/trunk/External/SPEC/CINT95/126.gcc/CMakeLists.txt

add_definitions(-DSPEC) add_definitions(-DSPEC)
list(APPEND CPPFLAGS -idirafter ${BENCHMARK_DIR}/src/src.alt) list(APPEND CPPFLAGS -idirafter ${BENCHMARK_DIR}/src/src.alt)
macro(test_input run_type input output) macro(test_input run_type input output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
-quiet -funroll-loops -fforce-mem -fcse-follow-jumps -quiet -funroll-loops -fforce-mem -fcse-follow-jumps
-fcse-skip-blocks -fexpensive-optimizations -fstrength-reduce -fpeephole -fcse-skip-blocks -fexpensive-optimizations -fstrength-reduce -fpeephole
-fschedule-insns -finline-functions -fschedule-insns2 -fschedule-insns -finline-functions -fschedule-insns2
-O ${BENCHMARK_DIR}/data/${run_type}/input/${input} -O data/${run_type}/input/${input}
-o ${CMAKE_CURRENT_BINARY_DIR}/${output} -o ${output}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test cccp.i cccp.s) test_input(test cccp.i cccp.s)
test_input(train amptjp.i amptjp.s) test_input(train amptjp.i amptjp.s)
file(GLOB inputs "${BENCHMARK_DIR}/data/ref/input/*.i") file(GLOB inputs "${BENCHMARK_DIR}/data/ref/input/*.i")
foreach(input ${inputs}) foreach(input ${inputs})
get_filename_component(basename "${input}" NAME_WE) get_filename_component(basename "${input}" NAME_WE)
test_input(ref ${basename}.o ${basename}.s) test_input(ref ${basename}.o ${basename}.s)
endforeach() endforeach()
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(126.gcc ${Source})
llvm_test_data_spec_default(126.gcc)

test-suite/trunk/External/SPEC/CINT95/129.compress/CMakeLists.txt

# iOS compiler have -Werror=return-value, need to disable this explicitely # iOS compiler have -Werror=return-value, need to disable this explicitely
# (-w is not enough) # (-w is not enough)
list(APPEND CFLAGS -Wno-return-type) list(APPEND CFLAGS -Wno-return-type)
macro(test_input run_type input output) macro(test_input run_type input output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
< ${BENCHMARK_DIR}/data/${run_type}/input/${input} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
> ${CMAKE_CURRENT_BINARY_DIR}/${output} < data/${run_type}/input/${input} > ${output}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test test.in test.out) test_input(test test.in test.out)
test_input(train test.in test.out) test_input(train test.in test.out)
test_input(ref bigtest.in bigtest.out) test_input(ref bigtest.in bigtest.out)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(129.compress ${Source})
llvm_test_data_spec_default(129.compress)

test-suite/trunk/External/SPEC/CINT95/130.li/CMakeLists.txt

# Work around usage of a reserved name (is* is reserved by the C standard and # Work around usage of a reserved name (is* is reserved by the C standard and
# isnumber is posix function) # isnumber is posix function)
add_definitions(-Disnumber=my_isnumber) add_definitions(-Disnumber=my_isnumber)
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${ARGN} ${ARGN}
> ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out > ${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${run_type}.out ${FPCMP} data/${run_type}/output/${run_type}.out ${run_type}.out
${CMAKE_CURRENT_BINARY_DIR}/${run_type}.out
) )
endmacro() endmacro()
test_input(test test.lsp) test_input(test test.lsp)
test_input(train train.lsp) test_input(train train.lsp)
test_input(ref au.lsp boyer.lsp browse.lsp ctak.lsp dderiv.lsp deriv.lsp test_input(ref au.lsp boyer.lsp browse.lsp ctak.lsp dderiv.lsp deriv.lsp
destru0.lsp destru1.lsp destru2.lsp destrum0.lsp destru0.lsp destru1.lsp destru2.lsp destrum0.lsp
destrum1.lsp destrum2.lsp div2.lsp puzzle0.lsp puzzle1.lsp destrum1.lsp destrum2.lsp div2.lsp puzzle0.lsp puzzle1.lsp
tak0.lsp tak1.lsp tak2.lsp takr.lsp triang.lsp xit.lsp) tak0.lsp tak1.lsp tak2.lsp takr.lsp triang.lsp xit.lsp)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(130.li ${Source})
llvm_test_data_spec_default(130.li)

test-suite/trunk/External/SPEC/CINT95/132.ijpeg/CMakeLists.txt

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
) )
set(Source "") set(Source "")
foreach(FILENAME ${SourceNames}) foreach(FILENAME ${SourceNames})
list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME}) list(APPEND Source ${BENCHMARK_DIR}/src/${FILENAME})
endforeach() endforeach()
macro(test_input run_type input output) macro(test_input run_type input output)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
-image_file ${input} -image_file ${input}
-compression.quality 90 -compression.quality 90
-compression.optimize_coding 0 -compression.optimize_coding 0
-compression.smoothing_factor 90 -compression.smoothing_factor 90
-difference.image 1 -difference.image 1
-difference.x_stride 10 -difference.x_stride 10
-difference.y_stride 10 -difference.y_stride 10
-verbose 1 -verbose 1
-GO.findoptcomp -GO.findoptcomp
> ${CMAKE_CURRENT_BINARY_DIR}/${output} > ${CMAKE_CURRENT_BINARY_DIR}/${output}
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${output} ${FPCMP} data/${run_type}/output/${output} ${output}
${CMAKE_CURRENT_BINARY_DIR}/${output}
) )
endmacro() endmacro()
test_input(test specmun.ppm specmun.out) test_input(test specmun.ppm specmun.out)
test_input(train vigo.ppm vigo.out) test_input(train vigo.ppm vigo.out)
test_input(ref penguin.ppm penguin.out) test_input(ref penguin.ppm penguin.out)
test_input(ref specmun.ppm specmun.out) test_input(ref specmun.ppm specmun.out)
test_input(ref vigo.ppm vigo.out) test_input(ref vigo.ppm vigo.out)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(132.ijpeg ${Source})
llvm_test_data_spec_default(132.ijpeg)

test-suite/trunk/External/SPEC/CINT95/134.perl/CMakeLists.txt

add_definitions(-DHAVE_STRERROR -DHAS_MKDIR -DHAS_RMDIR -DI_TIME) add_definitions(-DHAVE_STRERROR -DHAS_MKDIR -DHAS_RMDIR -DI_TIME)
macro(test_input run_type basename) macro(test_input run_type basename)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${basename}.pl ${basename}.pl
< ${BENCHMARK_DIR}/data/${run_type}/input/${basename}.in < ${basename}.in
> ${CMAKE_CURRENT_BINARY_DIR}/${basename}.out > ${CMAKE_CURRENT_BINARY_DIR}/${basename}.out
WORKDIR ${BENCHMARK_DIR}/data/${run_type}/input
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/${basename}.out ${FPCMP} data/${run_type}/output/${basename}.out ${basename}.out
${CMAKE_CURRENT_BINARY_DIR}/${basename}.out
) )
endmacro() endmacro()
test_input(test jumble) test_input(test jumble)
test_input(test primes) test_input(test primes)
test_input(train jumble) test_input(train jumble)
test_input(train primes) test_input(train primes)
test_input(train scrabbl) test_input(train scrabbl)
test_input(ref primes) test_input(ref primes)
test_input(ref scrabbl) test_input(ref scrabbl)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(134.perl ${Source})
llvm_test_data_spec_default(134.perl)

test-suite/trunk/External/SPEC/CINT95/147.vortex/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(CMAKE_SIZEOF_VOID_P EQUAL 8) if(CMAKE_SIZEOF_VOID_P EQUAL 8)
add_definitions(-D__RISC_64__) add_definitions(-D__RISC_64__)
endif() endif()
include(TestBigEndian) include(TestBigEndian)
if(IS_BIGENDIAN) if(IS_BIGENDIAN)
set(INPUTNAME "vortex.in.big") set(INPUTNAME "vortex.in.big")
else() else()
set(INPUTNAME "vortex.in.little") set(INPUTNAME "vortex.in.little")
endif() endif()
macro(test_input run_type) macro(test_input run_type)
llvm_test_run(RUN_TYPE ${run_type} llvm_test_run(RUN_TYPE ${run_type}
${INPUTNAME}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input WORKDIR ${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input
${INPUTNAME}
) )
llvm_test_verify(RUN_TYPE ${run_type} ${FPCMP} llvm_test_verify(RUN_TYPE ${run_type} WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
${BENCHMARK_DIR}/data/${run_type}/output/vortex.out ${FPCMP}
${CMAKE_CURRENT_BINARY_DIR}/data/${run_type}/input/vortex.out data/${run_type}/output/vortex.out
data/${run_type}/input/vortex.out
) )
endmacro() endmacro()
test_input(test) test_input(test)
test_input(train) test_input(train)
test_input(ref) test_input(ref)
llvm_test_executable(${PROG} ${Source}) llvm_test_executable(147.vortex ${Source})
llvm_test_data_spec(147.vortex MUST_COPY data)
# The benchmark writes the output where the input files are, so we have to
# copy the data over.
include(CopyDir)
llvm_copy_dir(${PROG} ${CMAKE_CURRENT_BINARY_DIR}/data ${BENCHMARK_DIR}/data)

test-suite/trunk/External/SPEC/SpecCPU2000.cmake

Show All 19 Lines")
if(CMAKE_SIZEOF_VOID_P EQUAL 8) if(CMAKE_SIZEOF_VOID_P EQUAL 8)
list(APPEND CPPFLAGS -DSPEC_CPU2000_LP64) list(APPEND CPPFLAGS -DSPEC_CPU2000_LP64)
endif() endif()
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
# Work around built in -Werror=implicit-function-declaration default on iOS # Work around built in -Werror=implicit-function-declaration default on iOS
list(APPEND CPPFLAGS -Wno-implicit-function-declaration) list(APPEND CPPFLAGS -Wno-implicit-function-declaration)
endif() endif()
function(llvm_test_data_spec target)
llvm_test_data(${target} SOURCE_DIR ${BENCHMARK_DIR} ${ARGN})
endfunction()
function(llvm_test_data_spec_default target)
llvm_test_data_spec(${target} data)
endfunction()
endif() endif()

test-suite/trunk/External/SPEC/SpecCPU2006.cmake

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines")
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
# Work around built in -Werror=implicit-function-declaration default on iOS # Work around built in -Werror=implicit-function-declaration default on iOS
list(APPEND CPPFLAGS -Wno-implicit-function-declaration) list(APPEND CPPFLAGS -Wno-implicit-function-declaration)
endif() endif()
macro(cpu2006_subdir BENCHMARK) macro(cpu2006_subdir BENCHMARK)
set(BENCHMARK_DIR ${TEST_SUITE_SPEC2006_ROOT}/benchspec/CPU2006/${BENCHMARK}) set(BENCHMARK_DIR ${TEST_SUITE_SPEC2006_ROOT}/benchspec/CPU2006/${BENCHMARK})
set(PROG ${BENCHMARK})
file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp ${BENCHMARK_DIR}/src/*.cc) file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp ${BENCHMARK_DIR}/src/*.cc)
add_subdirectory(${BENCHMARK}) add_subdirectory(${BENCHMARK})
endmacro() endmacro()
function(llvm_test_data_spec target)
llvm_test_data(${target} SOURCE_DIR ${BENCHMARK_DIR} ${ARGN})
endfunction()
function(llvm_test_data_spec_default target)
llvm_test_data_spec(${target} data)
endfunction()
endif() endif()

test-suite/trunk/External/SPEC/SpecCPU95.cmake

Show All 12 Linesif(TEST_SUITE_SPEC95_ROOT)
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
# Work around built in -Werror=implicit-function-declaration default on iOS # Work around built in -Werror=implicit-function-declaration default on iOS
list(APPEND CPPFLAGS -Wno-implicit-function-declaration) list(APPEND CPPFLAGS -Wno-implicit-function-declaration)
endif() endif()
macro(cint95_subdir BENCHMARK) macro(cint95_subdir BENCHMARK)
set(BENCHMARK_DIR ${TEST_SUITE_SPEC95_ROOT}/benchspec/CINT95/${BENCHMARK}) set(BENCHMARK_DIR ${TEST_SUITE_SPEC95_ROOT}/benchspec/CINT95/${BENCHMARK})
set(PROG ${BENCHMARK})
file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp) file(GLOB Source ${BENCHMARK_DIR}/src/*.c ${BENCHMARK_DIR}/src/*.cpp)
add_subdirectory(${BENCHMARK}) add_subdirectory(${BENCHMARK})
endmacro() endmacro()
function(llvm_test_data_spec target)
llvm_test_data(${target} SOURCE_DIR ${BENCHMARK_DIR} ${ARGN})
endfunction()
function(llvm_test_data_spec_default target)
llvm_test_data_spec(${target} data)
endfunction()
endif() endif()

test-suite/trunk/External/skidmarks10/CMakeLists.txt

include(External) include(External)
llvm_externals_find(TEST_SUITE_SKIDMARKS10_ROOT "skidmarks10" "Skidmarks 10") llvm_externals_find(TEST_SUITE_SKIDMARKS10_ROOT "skidmarks10" "Skidmarks 10")
if(TEST_SUITE_SKIDMARKS10_ROOT) if(TEST_SUITE_SKIDMARKS10_ROOT)
list(APPEND CPPFLAGS -I${TEST_SUITE_SKIDMARKS10_ROOT}/source) list(APPEND CPPFLAGS -I${TEST_SUITE_SKIDMARKS10_ROOT}/source)
if(ARCH STREQUAL "x86") if(ARCH STREQUAL "x86")
list(APPEND CFLAGS -msse3) list(APPEND CFLAGS -msse3)
endif() endif()
llvm_test_run(0 ${TEST_SUITE_SKIDMARKS10_ROOT}/golden llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
WORKDIR ${CMAKE_CURRENT_BINARY_DIR}) 0 golden
)
file(GLOB SOURCES ${TEST_SUITE_SKIDMARKS10_ROOT}/source/*.c) file(GLOB SOURCES ${TEST_SUITE_SKIDMARKS10_ROOT}/source/*.c)
llvm_test_executable(skidmarks ${SOURCES}) llvm_test_executable(skidmarks ${SOURCES})
llvm_test_data(skidmarks SOURCE_DIR ${TEST_SUITE_SKIDMARKS10_ROOT} golden)
endif() endif()

test-suite/trunk/MultiSource/Applications/ALAC/decode/CMakeLists.txt

if(ENDIAN STREQUAL "little") if(ENDIAN STREQUAL "little")
list(APPEND CFLAGS -DTARGET_RT_LITTLE_ENDIAN=1) list(APPEND CFLAGS -DTARGET_RT_LITTLE_ENDIAN=1)
list(APPEND CXXFLAGS -DTARGET_RT_LITTLE_ENDIAN=1) list(APPEND CXXFLAGS -DTARGET_RT_LITTLE_ENDIAN=1)
else() else()
list(APPEND CFLAGS -DTARGET_RT_BIG_ENDIAN=1) list(APPEND CFLAGS -DTARGET_RT_BIG_ENDIAN=1)
list(APPEND CXXFLAGS -DTARGET_RT_BIG_ENDIAN=1) list(APPEND CXXFLAGS -DTARGET_RT_BIG_ENDIAN=1)
endif() endif()
list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS - - < ${CMAKE_CURRENT_SOURCE_DIR}/tune.caf) set(RUN_OPTIONS - - < tune.caf)
llvm_multisource(alacconvert-decode llvm_multisource(alacconvert-decode
EndianPortable.c EndianPortable.c
ALACBitUtilities.c ALACBitUtilities.c
ALACDecoder.cpp ALACDecoder.cpp
ALACEncoder.cpp ALACEncoder.cpp
ag_dec.c ag_dec.c
ag_enc.c ag_enc.c
dp_dec.c dp_dec.c
dp_enc.c dp_enc.c
matrix_dec.c matrix_dec.c
matrix_enc.c matrix_enc.c
main.cpp main.cpp
CAFFileALAC.cpp CAFFileALAC.cpp
) )
llvm_test_data(alacconvert-decode tune.caf)

test-suite/trunk/MultiSource/Applications/ALAC/encode/CMakeLists.txt

if(ENDIAN STREQUAL "little") if(ENDIAN STREQUAL "little")
list(APPEND CFLAGS -DTARGET_RT_LITTLE_ENDIAN=1) list(APPEND CFLAGS -DTARGET_RT_LITTLE_ENDIAN=1)
list(APPEND CXXFLAGS -DTARGET_RT_LITTLE_ENDIAN=1) list(APPEND CXXFLAGS -DTARGET_RT_LITTLE_ENDIAN=1)
else() else()
list(APPEND CFLAGS -DTARGET_RT_BIG_ENDIAN=1) list(APPEND CFLAGS -DTARGET_RT_BIG_ENDIAN=1)
list(APPEND CXXFLAGS -DTARGET_RT_BIG_ENDIAN=1) list(APPEND CXXFLAGS -DTARGET_RT_BIG_ENDIAN=1)
endif() endif()
list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS - - < ${CMAKE_CURRENT_SOURCE_DIR}/tune.wav) set(RUN_OPTIONS - - < tune.wav)
llvm_multisource(alacconvert-encode llvm_multisource(alacconvert-encode
EndianPortable.c EndianPortable.c
ALACBitUtilities.c ALACBitUtilities.c
ALACDecoder.cpp ALACDecoder.cpp
ALACEncoder.cpp ALACEncoder.cpp
ag_dec.c ag_dec.c
ag_enc.c ag_enc.c
dp_dec.c dp_dec.c
dp_enc.c dp_enc.c
matrix_dec.c matrix_dec.c
matrix_enc.c matrix_enc.c
main.cpp main.cpp
CAFFileALAC.cpp CAFFileALAC.cpp
) )
llvm_test_data(alacconvert-encode tune.wav)

test-suite/trunk/MultiSource/Applications/Burg/CMakeLists.txt

list(APPEND CPPFLAGS -DDEBUG) list(APPEND CPPFLAGS -DDEBUG)
list(APPEND CFLAGS -std=gnu89) list(APPEND CFLAGS -std=gnu89)
list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/sample.gr) set(RUN_OPTIONS < sample.gr)
include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(burg) llvm_multisource(burg)
llvm_test_data(burg sample.gr)

test-suite/trunk/MultiSource/Applications/ClamAV/CMakeLists.txt

list(APPEND CPPFLAGS -DHAVE_CONFIG_H -I${CMAKE_CURRENT_SOURCE_DIR} -I${CMAKE_CURRENT_SOURCE_DIR}/zlib -DDONT_LOCK_DBDIRS) list(APPEND CPPFLAGS -DHAVE_CONFIG_H -I${CMAKE_CURRENT_SOURCE_DIR} -I${CMAKE_CURRENT_SOURCE_DIR}/zlib -DDONT_LOCK_DBDIRS)
set(INPUT set(INPUT
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clam.cab inputs/clam.cab
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clamdoc.tar.gz inputs/clamdoc.tar.gz
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clam.exe inputs/clam.exe
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clam.exe.bz2 inputs/clam.exe.bz2
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clam-v2.rar inputs/clam-v2.rar
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clam-v3.rar inputs/clam-v3.rar
${CMAKE_CURRENT_SOURCE_DIR}/inputs/clam.zip inputs/clam.zip
${CMAKE_CURRENT_SOURCE_DIR}/inputs/README inputs/README
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/Doc11.rtf inputs/rtf-test/Doc11.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/Doc1.rtf inputs/rtf-test/Doc1.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/Doc22.rtf inputs/rtf-test/Doc22.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/Doc2.rtf inputs/rtf-test/Doc2.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/doc3.rtf inputs/rtf-test/doc3.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/docCLAMexe.rtf inputs/rtf-test/docCLAMexe.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/rtf1.rtf inputs/rtf-test/rtf1.rtf
${CMAKE_CURRENT_SOURCE_DIR}/inputs/rtf-test/rtf-novirus.rtf inputs/rtf-test/rtf-novirus.rtf
) )
set(RUN_OPTIONS --debug --exclude-dir .svn --verbose -d${CMAKE_CURRENT_SOURCE_DIR}/dbdir -r ${INPUT}) set(RUN_OPTIONS --debug --exclude-dir .svn --verbose -d${CMAKE_CURRENT_BINARY_DIR}/dbdir -r ${INPUT})
if(TARGET_OS STREQUAL "Darwin") if(TARGET_OS STREQUAL "Darwin")
list(APPEND CPPFLAGS -DC_DARWIN) list(APPEND CPPFLAGS -DC_DARWIN)
endif() endif()
if(TARGET_OS STREQUAL "AIX") if(TARGET_OS STREQUAL "AIX")
list(APPEND CPPFLAGS -DC_AIX) list(APPEND CPPFLAGS -DC_AIX)
endif() endif()
if(TARGET_OS STREQUAL "IRIX") if(TARGET_OS STREQUAL "IRIX")
list(APPEND CPPFLAGS -DC_IRIX) list(APPEND CPPFLAGS -DC_IRIX)
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linesllvm_multisource(clamscan
zlib_infback.c zlib_infback.c
zlib_inffast.c zlib_inffast.c
zlib_inflate.c zlib_inflate.c
zlib_inftrees.c zlib_inftrees.c
zlib_trees.c zlib_trees.c
zlib_uncompr.c zlib_uncompr.c
zlib_zutil.c zlib_zutil.c
) )
llvm_test_data(clamscan ${INPUT} dbdir)

test-suite/trunk/MultiSource/Applications/JM/ldecod/CMakeLists.txt

list(APPEND CPPFLAGS -D__USE_LARGEFILE64 -D_FILE_OFFSET_BITS=64) list(APPEND CPPFLAGS -D__USE_LARGEFILE64 -D_FILE_OFFSET_BITS=64)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -i ${CMAKE_CURRENT_SOURCE_DIR}/data/test.264 -o Output/test_dec.yuv -r ${CMAKE_CURRENT_SOURCE_DIR}/data/test_rec.yuv) set(RUN_OPTIONS -i data/test.264 -o Output/test_dec.yuv -r data/test_rec.yuv)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(ldecod) llvm_multisource(ldecod)
llvm_test_data(ldecod data/test.264 data/test_rec.yuv)

test-suite/trunk/MultiSource/Applications/JM/lencod/CMakeLists.txt

list(APPEND CPPFLAGS -D__USE_LARGEFILE64 -D_FILE_OFFSET_BITS=64) list(APPEND CPPFLAGS -D__USE_LARGEFILE64 -D_FILE_OFFSET_BITS=64)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(FP_TOLERANCE 0.025) set(FP_TOLERANCE 0.025)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS -d ${CMAKE_CURRENT_SOURCE_DIR}/data/encoder_small.cfg -p InputFile=${CMAKE_CURRENT_SOURCE_DIR}/data/foreman_part_qcif_444.yuv -p LeakyBucketRateFile=${CMAKE_CURRENT_SOURCE_DIR}/data/leakybucketrate.cfg -p QmatrixFile=${CMAKE_CURRENT_SOURCE_DIR}/data/q_matrix.cfg) set(RUN_OPTIONS -d data/encoder_small.cfg -p InputFile=data/foreman_part_qcif_444.yuv -p LeakyBucketRateFile=data/leakybucketrate.cfg -p QmatrixFile=data/q_matrix.cfg)
else() else()
set(RUN_OPTIONS -d ${CMAKE_CURRENT_SOURCE_DIR}/data/encoder.cfg -p InputFile=${CMAKE_CURRENT_SOURCE_DIR}/data/foreman_part_qcif_444.yuv -p LeakyBucketRateFile=${CMAKE_CURRENT_SOURCE_DIR}/data/leakybucketrate.cfg -p QmatrixFile=${CMAKE_CURRENT_SOURCE_DIR}/data/q_matrix.cfg) set(RUN_OPTIONS -d data/encoder.cfg -p InputFile=data/foreman_part_qcif_444.yuv -p LeakyBucketRateFile=data/leakybucketrate.cfg -p QmatrixFile=data/q_matrix.cfg)
endif() endif()
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(lencod) llvm_multisource(lencod)
if(SMALL_PROBLEM_SIZE)
llvm_test_data(lencod data/encoder_small.cfg)
else()
llvm_test_data(lencod data/encoder.cfg)
endif()
llvm_test_data(lencod data/foreman_part_qcif_444.yuv data/leakybucketrate.cfg data/q_matrix.cfg)

test-suite/trunk/MultiSource/Applications/SIBsim4/CMakeLists.txt

if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS -A4 ${CMAKE_CURRENT_SOURCE_DIR}/x-small.fa ${CMAKE_CURRENT_SOURCE_DIR}/y-small.fa) set(INPUTS x-small.fa y-small.fa)
else() else()
set(RUN_OPTIONS -A4 ${CMAKE_CURRENT_SOURCE_DIR}/x.fa ${CMAKE_CURRENT_SOURCE_DIR}/y.fa) set(INPUTS x.fa y.fa)
endif() endif()
set(RUN_OPTIONS -A4 ${INPUTS})
llvm_multisource(SIBsim4) llvm_multisource(SIBsim4)
llvm_test_data(SIBsim4 ${INPUTS})

test-suite/trunk/MultiSource/Applications/SPASS/CMakeLists.txt

list(APPEND CPPFLAGS -DCLOCK_NO_TIMING) list(APPEND CPPFLAGS -DCLOCK_NO_TIMING)
list(APPEND CFLAGS -fno-strict-aliasing) list(APPEND CFLAGS -fno-strict-aliasing)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS "${CMAKE_CURRENT_SOURCE_DIR}/small_problem.dfg") set(INPUTS small_problem.dfg)
else() else()
set(RUN_OPTIONS "${CMAKE_CURRENT_SOURCE_DIR}/problem.dfg") set(INPUTS problem.dfg)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(SPASS) llvm_multisource(SPASS)
llvm_test_data(SPASS ${INPUTS})

test-suite/trunk/MultiSource/Applications/d/CMakeLists.txt

list(APPEND CPPFLAGS -DD_BUILD_VERSION=5725) list(APPEND CPPFLAGS -DD_BUILD_VERSION=5725)
set(RUN_OPTIONS -v ${CMAKE_CURRENT_SOURCE_DIR}/grammar.g) set(RUN_OPTIONS -v grammar.g)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(make_dparser llvm_multisource(make_dparser
make_dparser.c make_dparser.c
write_ctables.c write_ctables.c
gram.c gram.c
lex.c lex.c
lr.c lr.c
arg.c arg.c
parse.c parse.c
scan.c scan.c
symtab.c symtab.c
util.c util.c
version.c version.c
grammar.g.c grammar.g.c
) )
llvm_test_data(make_dparser grammar.g)

test-suite/trunk/MultiSource/Applications/hbd/CMakeLists.txt

list(APPEND CPPFLAGS -DHAVE_CONFIG_H) list(APPEND CPPFLAGS -DHAVE_CONFIG_H)
list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/Sort.class) set(RUN_OPTIONS Sort.class)
llvm_multisource(hbd) llvm_multisource(hbd)
llvm_test_data(hbd Sort.class)

test-suite/trunk/MultiSource/Applications/hexxagon/CMakeLists.txt

list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/input) set(RUN_OPTIONS < input)
llvm_multisource(hexxagon) llvm_multisource(hexxagon)
target_include_directories(hexxagon PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) target_include_directories(hexxagon PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
llvm_test_data(hexxagon input)

test-suite/trunk/MultiSource/Applications/kimwitu++/CMakeLists.txt

list(APPEND CPPFLAGS -I${CMAKE_CURRENT_SOURCE_DIR} -DYYDEBUG=1) list(APPEND CPPFLAGS -I${CMAKE_CURRENT_SOURCE_DIR} -DYYDEBUG=1)
list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS -f test -o -v -s kcc ${CMAKE_CURRENT_SOURCE_DIR}/inputs/f3.k ${CMAKE_CURRENT_SOURCE_DIR}/inputs/f2.k ${CMAKE_CURRENT_SOURCE_DIR}/inputs/f1.k) set(RUN_OPTIONS -f test -o -v -s kcc inputs/f3.k inputs/f2.k inputs/f1.k)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(kc) llvm_multisource(kc)
llvm_test_data(kc inputs/f3.k inputs/f2.k inputs/f1.k)

test-suite/trunk/MultiSource/Applications/lambda-0.1.3/CMakeLists.txt

list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/input) set(RUN_OPTIONS < input)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(lambda) llvm_multisource(lambda)
target_include_directories(lambda PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) target_include_directories(lambda PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
llvm_test_data(lambda input)

test-suite/trunk/MultiSource/Applications/lemon/CMakeLists.txt

if(NOT TEST_SUITE_BENCHMARKING_ONLY) if(NOT TEST_SUITE_BENCHMARKING_ONLY)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/parse.y ${CMAKE_CURRENT_SOURCE_DIR}/example1.y ${CMAKE_CURRENT_SOURCE_DIR}/example2.y ${CMAKE_CURRENT_SOURCE_DIR}/example3.y ${CMAKE_CURRENT_SOURCE_DIR}/example4.y ${CMAKE_CURRENT_SOURCE_DIR}/example5.y ${CMAKE_CURRENT_SOURCE_DIR}/lighttpd_configparser.y ${CMAKE_CURRENT_SOURCE_DIR}/lighttpd_mod_ssi_exprparser.y ${CMAKE_CURRENT_SOURCE_DIR}/wireshark_dtd_grammar.lemon ${CMAKE_CURRENT_SOURCE_DIR}/wireshark_grammar.lemon ${CMAKE_CURRENT_SOURCE_DIR}/wireshark_mate_grammar.lemon ${CMAKE_CURRENT_SOURCE_DIR}/xapian_queryparser.lemony ${CMAKE_CURRENT_SOURCE_DIR}/ecmascript.y) set(INPUTS parse.y example1.y example2.y example3.y example4.y example5.y lighttpd_configparser.y lighttpd_mod_ssi_exprparser.y wireshark_dtd_grammar.lemon wireshark_grammar.lemon wireshark_mate_grammar.lemon xapian_queryparser.lemony ecmascript.y)
set(RUN_OPTIONS ${INPUTS})
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(lemon lemon.c) llvm_multisource(lemon lemon.c)
llvm_test_data(lemon ${INPUTS} lempar.c)
endif() endif()

test-suite/trunk/MultiSource/Applications/lua/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(NOT ARCH STREQUAL "XCore") if(NOT ARCH STREQUAL "XCore")
list(APPEND CPPFLAGS -DLUA_USE_POSIX) list(APPEND CPPFLAGS -DLUA_USE_POSIX)
endif() endif()
set(RUN_OPTIONS alltests.lua "") set(RUN_OPTIONS alltests.lua "")
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/generate_inputs.sh add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/generate_inputs.sh
COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/generate_inputs.sh ${CMAKE_CURRENT_BINARY_DIR} COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/generate_inputs.sh ${CMAKE_CURRENT_BINARY_DIR}
COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/test ${CMAKE_CURRENT_BINARY_DIR} COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/test ${CMAKE_CURRENT_BINARY_DIR}
COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/bench ${CMAKE_CURRENT_BINARY_DIR} COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/bench ${CMAKE_CURRENT_BINARY_DIR}
COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/input ${CMAKE_CURRENT_BINARY_DIR} COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/input ${CMAKE_CURRENT_BINARY_DIR}
COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/*.lua ${CMAKE_CURRENT_BINARY_DIR} COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/*.lua ${CMAKE_CURRENT_BINARY_DIR}
Show All 37 Lines

test-suite/trunk/MultiSource/Applications/minisat/CMakeLists.txt

list(APPEND LDFLAGS -lstdc++ -lm) list(APPEND LDFLAGS -lstdc++ -lm)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS -verbosity=0 ${CMAKE_CURRENT_SOURCE_DIR}/small.cnf) set(INPUT small.cnf)
else() else()
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS -verbosity=0 ${CMAKE_CURRENT_SOURCE_DIR}/long.cnf) set(INPUT long.cnf)
else() else()
set(RUN_OPTIONS -verbosity=0 ${CMAKE_CURRENT_SOURCE_DIR}/short.cnf) set(INPUT short.cnf)
endif() endif()
endif() endif()
set(RUN_OPTIONS -verbosity=0 ${INPUT})
set(FP_TOLERANCE 0.1) set(FP_TOLERANCE 0.1)
llvm_multisource(minisat) llvm_multisource(minisat)
llvm_test_data(minisat ${INPUT})

test-suite/trunk/MultiSource/Applications/obsequi/CMakeLists.txt

list(APPEND CPPFLAGS -DCOUNTBITS16 -DLASTBIT16 -DCOUNTMOVES_TABLE) list(APPEND CPPFLAGS -DCOUNTBITS16 -DLASTBIT16 -DCOUNTMOVES_TABLE)
list(APPEND CPPFLAGS -DTWO_STAGE_GENERATION) list(APPEND CPPFLAGS -DTWO_STAGE_GENERATION)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
list(APPEND CPPFLAGS -DHASHCODEBITS=15) list(APPEND CPPFLAGS -DHASHCODEBITS=15)
else() else()
list(APPEND CPPFLAGS -DHASHCODEBITS=23) list(APPEND CPPFLAGS -DHASHCODEBITS=23)
endif() endif()
if(NOT "${ARCH}" STREQUAL "PowerPC") if(NOT "${ARCH}" STREQUAL "PowerPC")
list(APPEND LDFLAGS -lsupc++) list(APPEND LDFLAGS -lsupc++)
endif() endif()
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/input) set(RUN_OPTIONS < input)
llvm_multisource(Obsequi) llvm_multisource(Obsequi)
llvm_test_data(Obsequi input)

test-suite/trunk/MultiSource/Applications/oggenc/CMakeLists.txt

list(APPEND CFLAGS -fno-strict-aliasing) list(APPEND CFLAGS -fno-strict-aliasing)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -Q -s 901820 - < ${CMAKE_CURRENT_SOURCE_DIR}/tune) set(RUN_OPTIONS -Q -s 901820 - < tune)
llvm_multisource(oggenc) llvm_multisource(oggenc)
llvm_test_data(oggenc tune)

test-suite/trunk/MultiSource/Applications/siod/CMakeLists.txt

list(APPEND CPPFLAGS -D__USE_MISC -D__USE_GNU -D__USE_SVID -D__USE_XOPEN_EXTENDED -D__USE_XOPEN -Dunix) list(APPEND CPPFLAGS -D__USE_MISC -D__USE_GNU -D__USE_SVID -D__USE_XOPEN_EXTENDED -D__USE_XOPEN -Dunix)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -v1 ${CMAKE_CURRENT_SOURCE_DIR}/test.scm) set(RUN_OPTIONS -v1 test.scm)
llvm_multisource(siod) llvm_multisource(siod)
llvm_test_data(siod test.scm)

test-suite/trunk/MultiSource/Applications/spiff/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/Sample.3 ${CMAKE_CURRENT_SOURCE_DIR}/Sample.4) set(RUN_OPTIONS Sample.3 Sample.4)
llvm_multisource(spiff) llvm_multisource(spiff)
llvm_test_data(spiff Sample.3 Sample.4)

test-suite/trunk/MultiSource/Applications/sqlite3/CMakeLists.txt

list(APPEND CPPFLAGS -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DSQLITE_OMIT_LOAD_EXTENSION=1 -DSQLITE_THREADSAFE=0 -I.) list(APPEND CPPFLAGS -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DSQLITE_OMIT_LOAD_EXTENSION=1 -DSQLITE_THREADSAFE=0 -I.)
set(RUN_OPTIONS -init ${CMAKE_CURRENT_SOURCE_DIR}/sqlite3rc :memory: < ${CMAKE_CURRENT_SOURCE_DIR}/commands) set(RUN_OPTIONS -init sqlite3rc :memory: < commands)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
set(FP_TOLERANCE 1.0e-9) set(FP_TOLERANCE 1.0e-9)
set(GeneratedTestInputs ${CMAKE_CURRENT_BINARY_DIR}/test15.sql) set(GeneratedTestInputs ${CMAKE_CURRENT_BINARY_DIR}/test15.sql)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(SQLITE_INPUTNAME smalltest) set(SQLITE_INPUTNAME smalltest)
else() else()
set(SQLITE_INPUTNAME speedtest) set(SQLITE_INPUTNAME speedtest)
endif() endif()
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/test15.sql add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/test15.sql
COMMAND ${TCL_TCLSH} ${CMAKE_CURRENT_SOURCE_DIR}/${SQLITE_INPUTNAME}.tcl COMMAND ${TCL_TCLSH} ${CMAKE_CURRENT_SOURCE_DIR}/${SQLITE_INPUTNAME}.tcl
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating sqlite test inputs") COMMENT "Generating sqlite test inputs")
add_custom_target(sqlite_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/test15.sql) add_custom_target(sqlite_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/test15.sql)
llvm_multisource(sqlite3 llvm_multisource(sqlite3
sqlite3.c sqlite3.c
shell.c shell.c
) )
add_dependencies(sqlite3 sqlite_input) add_dependencies(sqlite3 sqlite_input)
llvm_test_data(sqlite3 sqlite3rc commands)

test-suite/trunk/MultiSource/Applications/treecc/CMakeLists.txt

set(RUN_OPTIONS -n ${CMAKE_CURRENT_SOURCE_DIR}/examples/expr_cpp.tc) set(RUN_OPTIONS -n examples/expr_cpp.tc)
llvm_multisource(treecc) llvm_multisource(treecc)
llvm_test_data(treecc examples/expr_cpp.tc)

test-suite/trunk/MultiSource/Applications/viterbi/CMakeLists.txt

list(APPEND CPPFLAGS -I${CMAKE_CURRENT_SOURCE_DIR} -DPROJ_SRC_DIR="${CMAKE_CURRENT_SOURCE_DIR}") list(APPEND CPPFLAGS -I${CMAKE_CURRENT_SOURCE_DIR} -DPROJ_SRC_DIR=".")
llvm_multisource(viterbi) llvm_multisource(viterbi)
llvm_test_data(viterbi Dist_demux)

test-suite/trunk/MultiSource/Benchmarks/ASC_Sequoia/IRSmk/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/irsmk_input) set(RUN_OPTIONS irsmk_input)
llvm_multisource(IRSmk) llvm_multisource(IRSmk)
llvm_test_data(IRSmk irsmk_input)

test-suite/trunk/MultiSource/Benchmarks/BitBench/drop3/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input-file) set(RUN_OPTIONS input-file)
llvm_multisource(drop3) llvm_multisource(drop3)
llvm_test_data(drop3 input-file)

test-suite/trunk/MultiSource/Benchmarks/BitBench/five11/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input-file) set(RUN_OPTIONS input-file)
llvm_multisource(five11) llvm_multisource(five11)
llvm_test_data(five11 input-file)

test-suite/trunk/MultiSource/Benchmarks/BitBench/uudecode/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input-file) set(RUN_OPTIONS input-file)
llvm_multisource(uudecode) llvm_multisource(uudecode)
llvm_test_data(uudecode input-file)

test-suite/trunk/MultiSource/Benchmarks/BitBench/uuencode/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input.txt) set(RUN_OPTIONS input.txt)
llvm_multisource(uuencode) llvm_multisource(uuencode)
llvm_test_data(uuencode input.txt)

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C++/PENNANT/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/intermediate_leblanc.pnt) set(RUN_OPTIONS intermediate_leblanc.pnt)
llvm_multisource(PENNANT) llvm_multisource(PENNANT)
llvm_test_data(PENNANT intermediate_leblanc.pnt)

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -x ${CMAKE_CURRENT_SOURCE_DIR}/medsmall1.adj_list) set(RUN_OPTIONS -x medsmall1.adj_list)
llvm_multisource(PathFinder) llvm_multisource(PathFinder)
llvm_test_data(PathFinder medsmall1.adj_list)

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/SimpleMOC/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CFLAGS -std=gnu99) list(APPEND CFLAGS -std=gnu99)
set(RUN_OPTIONS -i ${CMAKE_CURRENT_SOURCE_DIR}/default.in) set(RUN_OPTIONS -i default.in)
llvm_multisource(SimpleMOC) llvm_multisource(SimpleMOC)
llvm_test_data(SimpleMOC default.in)

test-suite/trunk/MultiSource/Benchmarks/Fhourstones-3.1/CMakeLists.txt

if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/inputs_large) set(INPUTS inputs_large)
else() else()
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/inputs) set(INPUTS inputs)
endif() endif()
set(RUN_OPTIONS < ${INPUTS})
llvm_multisource(fhourstones3.1) llvm_multisource(fhourstones3.1)
llvm_test_data(fhourstones3.1 ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/Fhourstones/CMakeLists.txt

list(APPEND CPPFLAGS -DUNIX -DTRANSIZE=1050011 -DPROBES=8 -DREPORTPLY=8) list(APPEND CPPFLAGS -DUNIX -DTRANSIZE=1050011 -DPROBES=8 -DREPORTPLY=8)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/input) set(RUN_OPTIONS < input)
llvm_multisource(fhourstones) llvm_multisource(fhourstones)
llvm_test_data(fhourstones input)

test-suite/trunk/MultiSource/Benchmarks/FreeBench/analyzer/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/ref.in) set(INPUTS ref.in)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/test.in) set(INPUTS test.in)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
llvm_multisource(analyzer) llvm_multisource(analyzer)
llvm_test_data(analyzer ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/FreeBench/distray/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/ref.in) set(INPUTS ref.in)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/test.in) set(INPUTS test.in)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(distray) llvm_multisource(distray)
llvm_test_data(distray ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/FreeBench/fourinarow/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/ref.in) set(INPUTS ref.in)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/test.in) set(INPUTS test.in)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
llvm_multisource(fourinarow) llvm_multisource(fourinarow)
llvm_test_data(fourinarow ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/FreeBench/mason/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/ref.in) set(INPUTS ref.in)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/test.in) set(INPUTS test.in)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
llvm_multisource(mason) llvm_multisource(mason)
llvm_test_data(mason ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/FreeBench/neural/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/ref.in) set(INPUTS ref.in)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/test.in) set(INPUTS test.in)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
llvm_multisource(neural) llvm_multisource(neural)
llvm_test_data(neural ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/FreeBench/pcompress2/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(INPUT_FILE ref.in) set(INPUT_FILE ref.in)
else() else()
set(INPUT_FILE test.in) set(INPUT_FILE test.in)
endif() endif()
set(RUN_OPTIONS ${CMAKE_CURRENT_BINARY_DIR}/${INPUT_FILE}) set(RUN_OPTIONS ${INPUT_FILE})
set(GeneratedTestInputs copy-input-file)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${INPUT_FILE}
COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/${INPUT_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${INPUT_FILE}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Copying pcompress2 test input")
add_custom_target(pcompress2_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${INPUT_FILE})
llvm_multisource(pcompress2) llvm_multisource(pcompress2)
add_dependencies(pcompress2 pcompress2_input) llvm_test_data(pcompress2 ${INPUT_FILE})

test-suite/trunk/MultiSource/Benchmarks/FreeBench/pifft/CMakeLists.txt

list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost") list(APPEND CPPFLAGS -DVERSION="1.00" -DCOMPDATE="today" -DCFLAGS="" -DHOSTNAME="thishost")
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/ref.in) set(INPUTS ref.in)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/test.in) set(INPUTS test.in)
endif() endif()
set(RUN_OPTIONS ${INPUTS})
llvm_multisource(pifft) llvm_multisource(pifft)
llvm_test_data(pifft ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/MallocBench/espresso/CMakeLists.txt

list(APPEND CPPFLAGS -DNOMEMOPT) list(APPEND CPPFLAGS -DNOMEMOPT)
list(APPEND CFLAGS -std=gnu89) list(APPEND CFLAGS -std=gnu89)
set(RUN_OPTIONS -t ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/largest.espresso) set(RUN_OPTIONS -t INPUT/largest.espresso)
llvm_multisource(espresso) llvm_multisource(espresso)
llvm_test_data(espresso INPUT/largest.espresso)

test-suite/trunk/MultiSource/Benchmarks/MallocBench/gawk/CMakeLists.txt

set(RUN_OPTIONS -f ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/adj.awk type=l linelen=70 indent=5 ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/words-large.awk) set(RUN_OPTIONS -f INPUT/adj.awk type=l linelen=70 indent=5 INPUT/words-large.awk)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CPPFLAGS -DBCOPY_MISSING -DSPRINTF_INT -DDOPRNT_MISSING -DGCVT_MISSING -DSTRCASE_MISSING -DSTRTOD_MISSING -DTMPNAM_MISSING) list(APPEND CPPFLAGS -DBCOPY_MISSING -DSPRINTF_INT -DDOPRNT_MISSING -DGCVT_MISSING -DSTRCASE_MISSING -DSTRTOD_MISSING -DTMPNAM_MISSING)
llvm_multisource(gawk llvm_multisource(gawk
alloca.c alloca.c
awk.tab.c awk.tab.c
debug.c debug.c
field.c field.c
main.c main.c
msg.c msg.c
regex.c regex.c
array.c array.c
builtin.c builtin.c
eval.c eval.c
io.c io.c
node.c node.c
) )
llvm_test_data(gawk INPUT/adj.awk INPUT/words-large.awk)

test-suite/trunk/MultiSource/Benchmarks/MallocBench/gs/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND CPPFLAGS -DNOMEMOPT -DGS_LIB_DEFAULT="${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_CURRENT_SOURCE_DIR}/fonts") list(APPEND CPPFLAGS -DNOMEMOPT -DGS_LIB_DEFAULT=".:./fonts")
list(APPEND CFLAGS -Wno-implicit-function-declaration) list(APPEND CFLAGS -Wno-implicit-function-declaration)
list(APPEND CPPFLAGS -DNOPRIVATE) list(APPEND CPPFLAGS -DNOPRIVATE)
set(RUN_OPTIONS -DNODISPLAY ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/large.ps) set(RUN_OPTIONS -DNODISPLAY INPUT/large.ps)
llvm_multisource(gs llvm_multisource(gs
gs.c gs.c
gsmain.c gsmain.c
gp_unix.c gp_unix.c
utrace.c utrace.c
ialloc.c ialloc.c
idebug.c idebug.c
idict.c idict.c
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesllvm_multisource(gs
gxfill.c gxfill.c
gxht.c gxht.c
gxpath.c gxpath.c
gxpath2.c gxpath2.c
gxstroke.c gxstroke.c
gdevmem.c gdevmem.c
gdevs.c gdevs.c
) )
llvm_test_data(gs
INPUT/large.ps
Fontmap
alphabet.ps
copyleft.ps
fcutils.ps
golfer.ps
prfont.ps
statusd.ps
bdftops.ps
decrypt.ps
gfonts.ps
lines.ps
ps2image.ps
traceop.ps
cheq.ps
empty.ps
ghost.ps
pcharstr.ps
pstoppm.ps
chess.ps
escher.ps
ghost2.ps
ppath.ps
quit.ps
)

test-suite/trunk/MultiSource/Benchmarks/MallocBench/make/CMakeLists.txt

list(APPEND CPPFLAGS -DHAVE_SIGLIST -DNO_LDAV -DNOMEMOPT -DPOSIX) list(APPEND CPPFLAGS -DHAVE_SIGLIST -DNO_LDAV -DNOMEMOPT -DPOSIX)
set(RUN_OPTIONS -n -f ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/GNUmakefile.make USEROPT=BWGC VPATH=${CMAKE_CURRENT_SOURCE_DIR}) set(RUN_OPTIONS -n -f INPUT/GNUmakefile.make USEROPT=BWGC)
llvm_multisource(make llvm_multisource(make
commands.c commands.c
job.c job.c
dir.c dir.c
file.c file.c
load.c load.c
misc.c misc.c
main.c main.c
read.c read.c
remake.c remake.c
remote.c remote.c
rule.c rule.c
implicit.c implicit.c
default.c default.c
variable.c variable.c
expand.c expand.c
function.c function.c
vpath.c vpath.c
version.c version.c
arscan.c arscan.c
ar.c ar.c
) )
llvm_test_data(make INPUT/GNUmakefile.make)

test-suite/trunk/MultiSource/Benchmarks/MallocBench/p2c/CMakeLists.txt

list(APPEND CPPFLAGS -DNOMEMOPT) list(APPEND CPPFLAGS -DNOMEMOPT)
set(RUN_OPTIONS -v < ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/mf.p) set(RUN_OPTIONS -v < INPUT/mf.p)
llvm_multisource(p2c) llvm_multisource(p2c)
llvm_test_data(p2c INPUT/mf.p)

test-suite/trunk/MultiSource/Benchmarks/MallocBench/perl/CMakeLists.txt

list(APPEND CPPFLAGS -DHAS_STRERROR -DHAS_MKDIR -DHAS_RMDIR -U_POSIX_SOURCE -D__USE_MISC) list(APPEND CPPFLAGS -DHAS_STRERROR -DHAS_MKDIR -DHAS_RMDIR -U_POSIX_SOURCE -D__USE_MISC)
list(APPEND LDFLAGS -lm -lcrypt) list(APPEND LDFLAGS -lm -lcrypt)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/endsort.perl ${CMAKE_CURRENT_SOURCE_DIR}/INPUT/endsort.perl) set(RUN_OPTIONS INPUT/endsort.perl INPUT/endsort.perl)
llvm_multisource(perl llvm_multisource(perl
array.c array.c
doarg.c doarg.c
eval.c eval.c
regexec.c regexec.c
cmd.c cmd.c
doio.c doio.c
form.c form.c
perl.c perl.c
stab.c stab.c
usersub.c usersub.c
cons.c cons.c
dolist.c dolist.c
hash.c hash.c
perly.c perly.c
str.c str.c
util.c util.c
consarg.c consarg.c
dump.c dump.c
malloc.c malloc.c
regcomp.c regcomp.c
toke.c toke.c
) )
llvm_test_data(perl INPUT)

test-suite/trunk/MultiSource/Benchmarks/McCat/01-qbsort/CMakeLists.txt

set(RUN_OPTIONS 1000 < ${CMAKE_CURRENT_SOURCE_DIR}/benchmark.in3)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS 1000 < benchmark.in3)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(qbsort) llvm_multisource(qbsort)
llvm_test_data(qbsort benchmark.in3)

test-suite/trunk/MultiSource/Benchmarks/McCat/03-testtrie/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/testtrie.in2) set(RUN_OPTIONS testtrie.in2)
llvm_multisource(testtrie) llvm_multisource(testtrie)
llvm_test_data(testtrie testtrie.in2)

test-suite/trunk/MultiSource/Benchmarks/McCat/04-bisect/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(FP_TOLERANCE 0.001) set(FP_TOLERANCE 0.001)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/bisect_test.in) set(RUN_OPTIONS < bisect_test.in)
llvm_multisource(bisect) llvm_multisource(bisect)
llvm_test_data(bisect bisect_test.in)

test-suite/trunk/MultiSource/Benchmarks/McCat/09-vor/CMakeLists.txt

set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/vor.in3) set(RUN_OPTIONS < vor.in3)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
llvm_multisource(vor) llvm_multisource(vor)
llvm_test_data(vor vor.in3)

test-suite/trunk/MultiSource/Benchmarks/McCat/15-trie/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
list(APPEND RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/trie.in1) list(APPEND RUN_OPTIONS trie.in1)
llvm_multisource(trie) llvm_multisource(trie)
llvm_test_data(trie trie.in1)

test-suite/trunk/MultiSource/Benchmarks/McCat/17-bintr/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/bnchmrk.in1) set(RUN_OPTIONS < bnchmrk.in1)
llvm_multisource(bintr) llvm_multisource(bintr)
llvm_test_data(bintr bnchmrk.in1)

test-suite/trunk/MultiSource/Benchmarks/McCat/18-imp/CMakeLists.txt

list(APPEND RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/sg01.imp)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ./sg01.imp)
llvm_multisource(imp) llvm_multisource(imp)
llvm_test_data(imp sg01.imp sg01.pgm)

test-suite/trunk/MultiSource/Benchmarks/MiBench/automotive-susan/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input_large.pgm /dev/null -s) set(RUN_OPTIONS input_large.pgm /dev/null -s)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(automotive-susan) llvm_multisource(automotive-susan)
llvm_test_data(automotive-susan input_large.pgm)

test-suite/trunk/MultiSource/Benchmarks/MiBench/consumer-jpeg/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -dct int -ppm -outfile /dev/null ${CMAKE_CURRENT_SOURCE_DIR}/input_large.jpg) set(RUN_OPTIONS -dct int -ppm -outfile /dev/null input_large.jpg)
llvm_multisource(consumer-jpeg) llvm_multisource(consumer-jpeg)
llvm_test_data(consumer-jpeg input_large.jpg)

test-suite/trunk/MultiSource/Benchmarks/MiBench/consumer-lame/CMakeLists.txt

list(APPEND CPPFLAGS -DHAVEMPGLIB -DLAMEPARSE -DNDEBUG -D__NO_MATH_INLINES -DLAMESNDFILE) list(APPEND CPPFLAGS -DHAVEMPGLIB -DLAMEPARSE -DNDEBUG -D__NO_MATH_INLINES -DLAMESNDFILE)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -S ${CMAKE_CURRENT_SOURCE_DIR}/large.wav /dev/null) set(RUN_OPTIONS -S large.wav /dev/null)
llvm_multisource(consumer-lame) llvm_multisource(consumer-lame)
llvm_test_data(consumer-lame large.wav)

test-suite/trunk/MultiSource/Benchmarks/MiBench/consumer-typeset/CMakeLists.txt

list(APPEND CPPFLAGS -DOS_UNIX=1 -DOS_DOS=0 -DOS_MAC=0 -DDB_FIX=0 -DUSE_STAT=1 -DSAFE_DFT=0 -DCOLLATE=1 -DLIB_DIR="lout.lib" -DFONT_DIR="font" -DMAPS_DIR="maps" -DINCL_DIR="include" -DDATA_DIR="data" -DHYPH_DIR="hyph" -DLOCALE_DIR="locale" -DCHAR_IN=1 -DCHAR_OUT=0 -DLOCALE_ON=1 -DASSERT_ON=1 -DDEBUG_ON=0 -DPDF_COMPRESSION=0 -D_FORTIFY_SOURCE=0) list(APPEND CPPFLAGS -DOS_UNIX=1 -DOS_DOS=0 -DOS_MAC=0 -DDB_FIX=0 -DUSE_STAT=1 -DSAFE_DFT=0 -DCOLLATE=1 -DLIB_DIR="lout.lib" -DFONT_DIR="font" -DMAPS_DIR="maps" -DINCL_DIR="include" -DDATA_DIR="data" -DHYPH_DIR="hyph" -DLOCALE_DIR="locale" -DCHAR_IN=1 -DCHAR_OUT=0 -DLOCALE_ON=1 -DASSERT_ON=1 -DDEBUG_ON=0 -DPDF_COMPRESSION=0 -D_FORTIFY_SOURCE=0)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -x -I ${CMAKE_CURRENT_SOURCE_DIR}/data/include -D ${CMAKE_CURRENT_SOURCE_DIR}/data/data -F ${CMAKE_CURRENT_SOURCE_DIR}/data/font -C ${CMAKE_CURRENT_SOURCE_DIR}/data/maps -H ${CMAKE_CURRENT_SOURCE_DIR}/data/hyph ${CMAKE_CURRENT_SOURCE_DIR}/large.lout) set(RUN_OPTIONS -x -I data/include -D data/data -F data/font -C data/maps -H data/hyph large.lout)
llvm_multisource(consumer-typeset) llvm_multisource(consumer-typeset)
llvm_test_data(consumer-typeset large.lout data)

test-suite/trunk/MultiSource/Benchmarks/MiBench/network-dijkstra/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input.dat) set(RUN_OPTIONS input.dat)
llvm_multisource(network-dijkstra) llvm_multisource(network-dijkstra)
llvm_test_data(network-dijkstra input.dat)

test-suite/trunk/MultiSource/Benchmarks/MiBench/network-patricia/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/large.udp) set(RUN_OPTIONS large.udp)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(network-patricia) llvm_multisource(network-patricia)
llvm_test_data(network-patricia large.udp)

test-suite/trunk/MultiSource/Benchmarks/MiBench/office-ispell/CMakeLists.txt

list(APPEND CPPFLAGS -Dconst=) list(APPEND CPPFLAGS -Dconst=)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -a -d ${CMAKE_CURRENT_SOURCE_DIR}/americanmed+ < ${CMAKE_CURRENT_SOURCE_DIR}/large.txt) set(RUN_OPTIONS -a -d americanmed+ < large.txt)
llvm_multisource(office-ispell) llvm_multisource(office-ispell)
llvm_test_data(office-ispell americanmed+.hash large.txt)

test-suite/trunk/MultiSource/Benchmarks/MiBench/security-rijndael/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/output_large.enc /dev/null d 1234567890abcdeffedcba09876543211234567890abcdeffedcba0987654321) set(RUN_OPTIONS output_large.enc /dev/null d 1234567890abcdeffedcba09876543211234567890abcdeffedcba0987654321)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(security-rijndael) llvm_multisource(security-rijndael)
llvm_test_data(security-rijndael output_large.enc)

test-suite/trunk/MultiSource/Benchmarks/MiBench/security-sha/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input_large.asc ) set(RUN_OPTIONS input_large.asc)
llvm_multisource(security-sha) llvm_multisource(security-sha)
llvm_test_data(security-sha input_large.asc)

test-suite/trunk/MultiSource/Benchmarks/MiBench/telecomm-CRC32/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/large.pcm) set(RUN_OPTIONS large.pcm)
llvm_multisource(telecomm-CRC32) llvm_multisource(telecomm-CRC32)
llvm_test_data(telecomm-CRC32 large.pcm)

test-suite/trunk/MultiSource/Benchmarks/MiBench/telecomm-adpcm/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/large.adpcm) set(RUN_OPTIONS < large.adpcm)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(telecomm-adpcm) llvm_multisource(telecomm-adpcm)
llvm_test_data(telecomm-adpcm large.adpcm)

test-suite/trunk/MultiSource/Benchmarks/MiBench/telecomm-gsm/CMakeLists.txt

list(APPEND CPPFLAGS -DSTUPID_COMPILER -DNeedFunctionPrototypes=1 -DSASR) list(APPEND CPPFLAGS -DSTUPID_COMPILER -DNeedFunctionPrototypes=1 -DSASR)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -fps -c ${CMAKE_CURRENT_SOURCE_DIR}/large.au) set(RUN_OPTIONS -fps -c large.au)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(telecomm-gsm) llvm_multisource(telecomm-gsm)
llvm_test_data(telecomm-gsm large.au)

test-suite/trunk/MultiSource/Benchmarks/PAQ8p/CMakeLists.txt

list(APPEND CPPFLAGS -DNOASM -DLLVM) list(APPEND CPPFLAGS -DNOASM -DLLVM)
list(APPEND LDFLAGS -lstdc++ -lm) list(APPEND LDFLAGS -lstdc++ -lm)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS -1 ${CMAKE_CURRENT_SOURCE_DIR}/small.in) set(INPUTS small.in)
set(RUN_OPTIONS -1 ${INPUTS})
else() else()
set(RUN_OPTIONS -4 ${CMAKE_CURRENT_SOURCE_DIR}/file1.in) set(INPUTS file1.in)
set(RUN_OPTIONS -4 ${INPUTS})
endif() endif()
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(paq8p) llvm_multisource(paq8p)
llvm_test_data(paq8p ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/Prolangs-C++/employ/CMakeLists.txt

list(APPEND LDFLAGS -lstdc++) list(APPEND LDFLAGS -lstdc++)
set(RUN_OPTIONS 400 < ${CMAKE_CURRENT_SOURCE_DIR}/input.txt) set(RUN_OPTIONS 400 < input.txt)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(employ) llvm_multisource(employ)
llvm_test_data(employ input.txt)

test-suite/trunk/MultiSource/Benchmarks/Prolangs-C/agrep/CMakeLists.txt

set(RUN_OPTIONS -2 int ${CMAKE_CURRENT_SOURCE_DIR}/InstructionCombining.cpp.txt) set(RUN_OPTIONS -2 int InstructionCombining.cpp.txt)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(agrep) llvm_multisource(agrep)
llvm_test_data(agrep InstructionCombining.cpp.txt)

test-suite/trunk/MultiSource/Benchmarks/Prolangs-C/bison/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/parse.y.in -v) set(RUN_OPTIONS parse.y.in -v)
llvm_multisource(mybison) llvm_multisource(mybison)
llvm_test_data(mybison parse.y.in)

test-suite/trunk/MultiSource/Benchmarks/Prolangs-C/cdecl/CMakeLists.txt

list(APPEND CFLAGS -std=gnu89) list(APPEND CFLAGS -std=gnu89)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/testset) set(RUN_OPTIONS < testset)
llvm_multisource(cdecl) llvm_multisource(cdecl)
llvm_test_data(cdecl testset)

test-suite/trunk/MultiSource/Benchmarks/Prolangs-C/gnugo/CMakeLists.txt

set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/stdin) set(RUN_OPTIONS < stdin)
llvm_multisource(gnugo) llvm_multisource(gnugo)
llvm_test_data(gnugo stdin)

test-suite/trunk/MultiSource/Benchmarks/Prolangs-C/unix-smail/CMakeLists.txt

set(RUN_OPTIONS -v ALL < ${CMAKE_CURRENT_SOURCE_DIR}/main.c) set(RUN_OPTIONS -v ALL < main.c)
llvm_multisource(unix-smail) llvm_multisource(unix-smail)
llvm_test_data(unix-smail main.c)

test-suite/trunk/MultiSource/Benchmarks/Ptrdist/anagram/CMakeLists.txt

set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/words 2 < ${CMAKE_CURRENT_SOURCE_DIR}/input.OUT) set(RUN_OPTIONS words 2 < input.OUT)
llvm_multisource(anagram) llvm_multisource(anagram)
llvm_test_data(anagram words input.OUT)

test-suite/trunk/MultiSource/Benchmarks/Ptrdist/bc/CMakeLists.txt

set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/primes.b) set(RUN_OPTIONS < primes.b)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(bc) llvm_multisource(bc)
llvm_test_data(bc primes.b)

test-suite/trunk/MultiSource/Benchmarks/Ptrdist/ks/CMakeLists.txt

list(APPEND RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/KL-4.in) set(RUN_OPTIONS KL-4.in)
llvm_multisource(ks) llvm_multisource(ks)
llvm_test_data(ks KL-4.in)

test-suite/trunk/MultiSource/Benchmarks/Ptrdist/yacr2/CMakeLists.txt

list(APPEND CPPFLAGS -DTODD) list(APPEND CPPFLAGS -DTODD)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input2.in) set(RUN_OPTIONS input2.in)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(yacr2) llvm_multisource(yacr2)
llvm_test_data(yacr2 input2.in)

test-suite/trunk/MultiSource/Benchmarks/Rodinia/hotspot/CMakeLists.txt

set(FP_ABSTOLERANCE 0.00001) set(FP_ABSTOLERANCE 0.00001)
list(APPEND CFLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/../Common) list(APPEND CFLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/../Common)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(hotspot llvm_multisource(hotspot
hotspotKernel.c hotspotKernel.c
main.c main.c
../Common/glibc_compat_rand.c ../Common/glibc_compat_rand.c
) )

test-suite/trunk/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(FP_ABSTOLERANCE 0.00001) set(FP_ABSTOLERANCE 0.00001)
list(APPEND CFLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/../Common) list(APPEND CFLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/../Common)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(srad llvm_multisource(srad
main.c main.c
sradKernel.c sradKernel.c
../Common/glibc_compat_rand.c ../Common/glibc_compat_rand.c
) )

test-suite/trunk/MultiSource/Benchmarks/Trimaran/netbench-url/CMakeLists.txt

if(LARGE_PROBLEM_SIZE) if(LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/medium_inputs 1400) set(RUN_OPTIONS medium_inputs 1400)
else() else()
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/medium_inputs 100) set(RUN_OPTIONS medium_inputs 100)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/medium_inputs 900) set(RUN_OPTIONS medium_inputs 900)
endif() endif()
endif() endif()
llvm_multisource(netbench-url) llvm_multisource(netbench-url)
llvm_test_data(netbench-url medium_inputs)

test-suite/trunk/MultiSource/Benchmarks/VersaBench/8b10b/CMakeLists.txt

if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input.txt 2000) set(RUN_OPTIONS input.txt 2000)
else() else()
set(RUN_OPTIONS ${CMAKE_CURRENT_SOURCE_DIR}/input.txt 20000) set(RUN_OPTIONS input.txt 20000)
endif() endif()
llvm_multisource(8b10b) llvm_multisource(8b10b)
llvm_test_data(8b10b input.txt)

test-suite/trunk/MultiSource/Benchmarks/VersaBench/dbms/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS -i ${CMAKE_CURRENT_SOURCE_DIR}/dbms.train.in) set(INPUTS dbms.train.in)
set(RUN_OPTIONS -i ${INPUTS})
else() else()
set(RUN_OPTIONS -i ${CMAKE_CURRENT_SOURCE_DIR}/dbms.ref.in) set(INPUTS dbms.ref.in)
set(RUN_OPTIONS -i ${INPUTS})
endif() endif()
llvm_multisource(dbms) llvm_multisource(dbms)
llvm_test_data(dbms ${INPUTS})

test-suite/trunk/MultiSource/Benchmarks/mafft/CMakeLists.txt

list(APPEND CPPFLAGS -DLLVM) list(APPEND CPPFLAGS -DLLVM)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(RUN_OPTIONS -b 62 -g 0.100 -f 2.00 -h 0.100 -L < ${CMAKE_CURRENT_SOURCE_DIR}/pyruvate_decarboxylase.fasta) set(RUN_OPTIONS -b 62 -g 0.100 -f 2.00 -h 0.100 -L < pyruvate_decarboxylase.fasta)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(pairlocalalign llvm_multisource(pairlocalalign
Calignm1.c Calignm1.c
constants.c constants.c
defs.c defs.c
Falign.c Falign.c
fft.c fft.c
fftFunctions.c fftFunctions.c
Show All 14 Linesllvm_multisource(pairlocalalign
Qalignmm.c Qalignmm.c
Ralignmm.c Ralignmm.c
rna.c rna.c
SAalignmm.c SAalignmm.c
Salignmm.c Salignmm.c
suboptalign11.c suboptalign11.c
tddis.c tddis.c
) )
llvm_test_data(pairlocalalign pyruvate_decarboxylase.fasta)

test-suite/trunk/MultiSource/Benchmarks/mediabench/adpcm/rawcaudio/CMakeLists.txt

set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/../data/clinton.pcm ) set(RUN_OPTIONS < clinton.pcm)
llvm_multisource(rawcaudio llvm_multisource(rawcaudio
rawcaudio.c rawcaudio.c
adpcm.c adpcm.c
) )
llvm_test_data(rawcaudio SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../data
clinton.pcm
)

test-suite/trunk/MultiSource/Benchmarks/mediabench/adpcm/rawdaudio/CMakeLists.txt

set(RUN_OPTIONS < ${CMAKE_CURRENT_SOURCE_DIR}/../data/clinton.adpcm ) set(RUN_OPTIONS < clinton.adpcm)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
llvm_multisource(rawdaudio llvm_multisource(rawdaudio
rawdaudio.c rawdaudio.c
adpcm.c adpcm.c
) )
llvm_test_data(rawdaudio SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../data
clinton.adpcm
)

test-suite/trunk/MultiSource/Benchmarks/mediabench/g721/g721encode/CMakeLists.txt

set(RUN_OPTIONS -4 -l < ${CMAKE_CURRENT_SOURCE_DIR}/../data/clinton.pcm) set(RUN_OPTIONS -4 -l < clinton.pcm)
llvm_multisource(encode llvm_multisource(encode
encode.c encode.c
g711.c g711.c
g721.c g721.c
g723_24.c g723_24.c
g723_40.c g723_40.c
g72x.c g72x.c
) )
llvm_test_data(encode SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../data
clinton.pcm
)

test-suite/trunk/MultiSource/Benchmarks/mediabench/gsm/toast/CMakeLists.txt

set(RUN_OPTIONS -cpl ${CMAKE_CURRENT_SOURCE_DIR}/../data/clinton.pcm) set(RUN_OPTIONS -cpl clinton.pcm)
list(APPEND CPPFLAGS -DNeedFunctionPrototypes=1 -DSASR) list(APPEND CPPFLAGS -DNeedFunctionPrototypes=1 -DSASR)
llvm_multisource(toast llvm_multisource(toast
add.c add.c
gsm_decode.c gsm_decode.c
gsm_option.c gsm_option.c
rpe.c rpe.c
toast.c toast.c
code.c code.c
Show All 10 Linesllvm_multisource(toast
gsm_explode.c gsm_explode.c
lpc.c lpc.c
toast_alaw.c toast_alaw.c
gsm_create.c gsm_create.c
gsm_implode.c gsm_implode.c
preprocess.c preprocess.c
toast_audio.c toast_audio.c
) )
llvm_test_data(toast SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../data
clinton.pcm
)

test-suite/trunk/MultiSource/Benchmarks/mediabench/jpeg/jpeg-6a/CMakeLists.txt

set(RUN_OPTIONS -dct int -progressive -opt ${CMAKE_CURRENT_SOURCE_DIR}/../data/testimg.ppm) set(RUN_OPTIONS -dct int -progressive -opt testimg.ppm)
llvm_multisource(cjpeg llvm_multisource(cjpeg
jcapimin.c jcapimin.c
jcapistd.c jcapistd.c
jctrans.c jctrans.c
jcparam.c jcparam.c
jdatadst.c jdatadst.c
jcinit.c jcinit.c
jcmaster.c jcmaster.c
Show All 40 Linesllvm_multisource(cjpeg
rdppm.c rdppm.c
rdgif.c rdgif.c
rdtarga.c rdtarga.c
rdrle.c rdrle.c
rdbmp.c rdbmp.c
rdswitch.c rdswitch.c
cdjpeg.c cdjpeg.c
) )
llvm_test_data(cjpeg SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../data
testimg.ppm
)

test-suite/trunk/MultiSource/Benchmarks/mediabench/mpeg2/mpeg2dec/CMakeLists.txt

set(RUN_OPTIONS -b ${CMAKE_CURRENT_SOURCE_DIR}/../data/mei16v2.m2v -r -f -o0 ${CMAKE_CURRENT_BINARY_DIR}/tmp%d) set(RUN_OPTIONS -b mei16v2.m2v -r -f -o0 tmp%d)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
llvm_multisource(mpeg2decode llvm_multisource(mpeg2decode
display.c display.c
gethdr.c gethdr.c
idct.c idct.c
mpeg2dec.c mpeg2dec.c
store.c store.c
verify.c verify.c
getbits.c getbits.c
getpic.c getpic.c
idctref.c idctref.c
recon.c recon.c
subspic.c subspic.c
getblk.c getblk.c
getvlc.c getvlc.c
motion.c motion.c
spatscal.c spatscal.c
systems.c systems.c
) )
llvm_test_data(mpeg2decode SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../data
mei16v2.m2v
)

test-suite/trunk/MultiSource/Benchmarks/nbench/CMakeLists.txt

list(APPEND CPPFLAGS -DBASE_ITERATIONS=25) list(APPEND CPPFLAGS -DBASE_ITERATIONS=25)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/NNET.DAT
COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/NNET.DAT ${CMAKE_CURRENT_BINARY_DIR}/NNET.DAT
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Copying nbench test input")
add_custom_target(nbench_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/NNET.DAT)
llvm_multisource(nbench) llvm_multisource(nbench)
add_dependencies(nbench nbench_input) llvm_test_data(nbench NNET.DAT)

test-suite/trunk/MultiSource/Benchmarks/sim/CMakeLists.txt

list(APPEND CPPFLAGS -DUNIX) list(APPEND CPPFLAGS -DUNIX)
set(RUN_OPTIONS 8 ${CMAKE_CURRENT_SOURCE_DIR}/tob.38-44 ${CMAKE_CURRENT_SOURCE_DIR}/liv.42-48) set(RUN_OPTIONS 8 tob.38-44 liv.42-48)
set(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
llvm_multisource(sim) llvm_multisource(sim)
llvm_test_data(sim tob.38-44 liv.42-48)

test-suite/trunk/cmake/modules/CopyDir.cmake

Show All 9 Lines
endfunction() endfunction()
function(llvm_copy target to from) function(llvm_copy target to from)
add_custom_command( add_custom_command(
TARGET ${target} POST_BUILD TARGET ${target} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy ${from} ${to} COMMAND ${CMAKE_COMMAND} -E copy ${from} ${to}
) )
endfunction() endfunction()
function(llvm_create_symlink target to from)
add_custom_command(
TARGET ${target} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E create_symlink ${from} ${to}
)
endfunction()
function(llvm_make_directory target)
add_custom_command(
TARGET ${target} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E make_directory ${ARGN}
)
endfunction()

test-suite/trunk/cmake/modules/SingleMultiSource.cmake

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesmacro(basename Var name)
# remove shortest extension. # remove shortest extension.
string(REGEX REPLACE "\\.[^.]*$" "" ${Var} ${_filename}) string(REGEX REPLACE "\\.[^.]*$" "" ${Var} ${_filename})
endmacro() endmacro()
# Traditionally CMakeLists.txt files would set RUN_OPTIONS, SMALL_PROBLEM_SIZE, # Traditionally CMakeLists.txt files would set RUN_OPTIONS, SMALL_PROBLEM_SIZE,
# HASH_PROGRAM_OUTPUT, etc. # HASH_PROGRAM_OUTPUT, etc.
# Create llvm_test_run() and llvm_test_verify() invocation for that. # Create llvm_test_run() and llvm_test_verify() invocation for that.
function(llvm_test_traditional name) function(llvm_test_traditional name)
if(WORKDIR) # Always run in the same directory as the executable
list(APPEND RUN_OPTIONS WORKDIR ${WORKDIR}) list(INSERT RUN_OPTIONS 0 WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
endif()
llvm_test_run(${RUN_OPTIONS}) llvm_test_run(${RUN_OPTIONS})
# Hash if we've been asked to. # Hash if we've been asked to.
if(HASH_PROGRAM_OUTPUT) if(HASH_PROGRAM_OUTPUT)
llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh %o") llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh %o")
endif() endif()
# Find the reference output file key name. # Find the reference output file key name.
Show All 34 Lines

test-suite/trunk/cmake/modules/TestSuite.cmake

##===- TestSuite.cmake ----------------------------------------------------===## ##===- TestSuite.cmake ----------------------------------------------------===##
# #
# Defines helper functions to build benchmarks and the corresponding .test files # Defines helper functions to build benchmarks and the corresponding .test files
# #
##===----------------------------------------------------------------------===## ##===----------------------------------------------------------------------===##
include(TestFile) include(TestFile)
include(CopyDir)
# Copies files and directories to be used as benchmark input data to the
# directory of the benchmark executable.
# Paths are interepreted relative to CMAKE_CURRENT_SOURCE_DIR by default but
# this can be changed with the SOURCE_DIR argument.
function(llvm_test_data target)
cmake_parse_arguments(_LTDARGS "MUST_COPY" "SOURCE_DIR" "" ${ARGN})
set(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
if(_LTDARGS_SOURCE_DIR)
set(SOURCE_DIR ${_LTDARGS_SOURCE_DIR})
endif()
foreach(file ${_LTDARGS_UNPARSED_ARGUMENTS})
set(full_path ${SOURCE_DIR}/${file})
if(_LTDARGS_MUST_COPY)
if(IS_DIRECTORY ${full_path})
llvm_copy_dir(${target} $<TARGET_FILE_DIR:${target}>/${file} ${full_path})
else()
llvm_copy(${target} $<TARGET_FILE_DIR:${target}>/${file} ${full_path})
endif()
else()
get_filename_component(file_subdir ${file} DIRECTORY)
if(file_subdir)
llvm_make_directory(${target} ${file_subdir})
endif()
llvm_create_symlink(${target} $<TARGET_FILE_DIR:${target}>/${file} ${full_path})
endif()
endforeach()
endfunction()
# Creates a new executable build target. Use this instead of `add_executable`. # Creates a new executable build target. Use this instead of `add_executable`.
# It applies CFLAGS, CPPFLAGS, CXXFLAGS and LDFLAGS. Creates a .test file if # It applies CFLAGS, CPPFLAGS, CXXFLAGS and LDFLAGS. Creates a .test file if
# necessary, registers the target with the TEST_SUITE_TARGETS list and makes # necessary, registers the target with the TEST_SUITE_TARGETS list and makes
# sure we build the required dependencies for compiletime measurements # sure we build the required dependencies for compiletime measurements
# and support the TEST_SUITE_PROFILE_USE mode. # and support the TEST_SUITE_PROFILE_USE mode.
function(llvm_test_executable target) function(llvm_test_executable target)
add_executable(${target} ${ARGN}) add_executable(${target} ${ARGN})
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines