Index: CMakeLists.txt
===================================================================
--- /dev/null
+++ CMakeLists.txt
@@ -0,0 +1,73 @@
+cmake_minimum_required(VERSION 2.8.12.2)
+
+# The test-suite is designed to be built in release mode anyway and
+# falls over unless -DNDEBUG is set.
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+ message(STATUS "No build type selected, defaulting to Release")
+ set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+add_definitions(-DNDEBUG)
+
+# Let's make sure lit output is pretty.
+if(CMAKE_VERSION VERSION_LESS 3.1.20141117)
+ set(cmake_3_2_USES_TERMINAL)
+else()
+ set(cmake_3_2_USES_TERMINAL USES_TERMINAL)
+endif()
+
+project(test-suite C CXX)
+
+# Add path for custom modules
+set(CMAKE_MODULE_PATH
+ ${CMAKE_MODULE_PATH}
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
+ )
+
+# Sanity check our source directory to make sure that we are not trying to
+# generate an in-tree build (unless on MSVC_IDE, where it is ok), and to make
+# sure that we don't have any stray generated files lying around in the tree
+# (which would end up getting picked up by header search, instead of the correct
+# versions).
+if( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
+ message(FATAL_ERROR "In-source builds are not allowed.
+CMake would overwrite the makefiles distributed with LLVM.
+Please create a directory and run cmake from there, passing the path
+to this source directory as the last argument.
+This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
+Please delete them.")
+endif()
+
+include(MakefileFunctions)
+include(SingleMultiSource)
+find_package(YACC)
+find_package(TCL)
+
+# FIXME: Detect host architecture, endianness and OS
+if(NOT DEFINED TARGET_OS)
+ message(STATUS "Check target operating system - ${CMAKE_SYSTEM_NAME}")
+ set(TARGET_OS ${CMAKE_SYSTEM_NAME})
+endif()
+if(NOT DEFINED ARCH)
+ include(DetectArchitecture)
+ detect_architecture(ARCH)
+endif()
+if(NOT DEFINED ENDIAN)
+ include(TestBigEndian)
+ test_big_endian(IS_BIGENDIAN)
+ if(IS_BIGENDIAN)
+ set(ENDIAN "big")
+ else()
+ set(ENDIAN "little")
+ endif()
+endif()
+
+add_subdirectory(tools)
+
+# Now that the tools have been created,
+set(CMAKE_C_COMPILE_OBJECT "${CMAKE_BINARY_DIR}/tools/timeit --summary <OBJECT>.time ${CMAKE_C_COMPILE_OBJECT}")
+set(CMAKE_CXX_COMPILE_OBJECT "${CMAKE_BINARY_DIR}/tools/timeit --summary <OBJECT>.time ${CMAKE_CXX_COMPILE_OBJECT}")
+
+add_subdirectory(SingleSource)
+add_subdirectory(MultiSource)
Index: cmake/Makefile2CMakeLists.py
===================================================================
--- /dev/null
+++ cmake/Makefile2CMakeLists.py
@@ -0,0 +1,337 @@
+##===- Makefile2CMakeLists.py ---------------------------------------------===##
+#
+# This script parses Makefiles in the SingleSource and MultiSource directories
+# and generates equivalent CMakeLists.txt files.
+#
+# This script is intended to be run as a one-shot process, with its generated
+# CMakeLists.txt checked in to the tree. Once this is done and dusted, this
+# script can be deleted from the tree as it serves no more useful purpose.
+#
+# This script requires `pymake`: https://github.com/mozilla/pymake
+# This is not available on PyPI so will need to be downloaded manually and
+# `pip install -e`'d.
+#
+# Usage: cd $TEST_SUITE_ROOT; python Makefile2CMakeLists.py
+#
+# Improvements required before prime-time:
+# * Copy across comments from the Makefiles into the generated CMakeLists.
+##===----------------------------------------------------------------------===##
+
+import os, sys, fnmatch, re
+
+from pymake.parserdata import *
+from pymake.parser import parsefile, parsemakesyntax, Data
+import pymake.data as data
+import pymake.functions as functions
+
+class Stream(object):
+ def __init__(self):
+ self.s = ""
+ self._indent = 0
+ self.tmp = 0
+ def writeLine(self, line):
+ self.s += ' ' * self._indent
+ self.s += line + "\n"
+ def indent(self, i):
+ self._indent += i
+ def str(self):
+ return self.s
+ def tempvar(self):
+ self.tmp += 1
+ return "TMP%s" % self.tmp
+
+def _deref(s):
+ return "${%s}" % s
+
+def _deescape_in_string(s):
+ # This is particularly targetted at the escape in lua/Makefile :(
+ s = re.sub(r'"\\<in', r'"', s)
+ # And this one is targetted at FreeBench :(
+ s = s.replace(r'\"', r'\\"')
+ return s
+
+def generate_Expansion(e, outstream):
+ if e.__class__ == data.StringExpansion:
+ s = e.s
+ s = s.replace('y.tab.c', '${CMAKE_CURRENT_BINARY_DIR}/y.tab.c')
+ s = s.replace('awk.tab.c', '${CMAKE_CURRENT_BINARY_DIR}/awk.tab.c')
+ # Make sure we properly escape backslashes
+ return '%s' % _deescape_in_string(s)
+ if e.__class__ == data.Expansion:
+ s = []
+ for e2, isfunc in e:
+ if isfunc:
+ s.append(generate_Expansion(e2, outstream))
+ else:
+ assert isinstance(e2, basestring)
+ s.append('%s' % e2.replace('\\','\\\\'))
+ return ''.join(s)
+ if e.__class__ == functions.VariableRef:
+ # Special case for PROJ_SRC_ROOT and PROJ_SRC_DIR
+ if e.vname.s == "PROJ_SRC_ROOT":
+ return '${CMAKE_SOURCE_DIR}'
+ if e.vname.s == "PROJ_SRC_DIR":
+ return '${CMAKE_CURRENT_SOURCE_DIR}'
+ if e.vname.s == "PROJ_OBJ_DIR":
+ return '${CMAKE_CURRENT_BINARY_DIR}'
+ if e.vname.s == "SourceDir":
+ return '${CMAKE_CURRENT_SOURCE_DIR}'
+ return '${%s}' % e.vname.s
+ if e.__class__ == functions.ShellFunction:
+ args = generate_Expansion(e._arguments[0], outstream)
+ t = outstream.tempvar()
+ outstream.writeLine('execute_process(COMMAND %s OUTPUT_VARIABLE %s)' % (args, t))
+ return t
+ if e.__class__ == functions.WildcardFunction:
+ args = generate_Expansion(e._arguments[0], outstream)
+ t = outstream.tempvar()
+ outstream.writeLine('file(GLOB %s %s)' % (t, args))
+ return _deref(t)
+ if e.__class__ == functions.AddPrefixFunction:
+ args = generate_Expansion(e._arguments[1], outstream)
+ t = outstream.tempvar()
+ prefix = generate_Expansion(e._arguments[0], outstream)
+ # Comma-separated list!
+ args = args.replace(', ', ' ')
+ outstream.writeLine('set(%s %s)' % (t, args))
+ outstream.writeLine('llvm_prepend(%s %s %s)' % (t, prefix, _deref(t)))
+ return _deref(t)
+ if e.__class__ == functions.SubstFunction:
+ s = generate_Expansion(e._arguments[0], outstream)
+ r = generate_Expansion(e._arguments[1], outstream)
+ d = generate_Expansion(e._arguments[2], outstream)
+ t = outstream.tempvar()
+ outstream.writeLine('string(REPLACE %s %s %s %s)' % (s, r, t, d))
+ return _deref(t)
+ if e.__class__ == functions.FilteroutFunction:
+ source = generate_Expansion(e._arguments[0], outstream)
+ out = generate_Expansion(e._arguments[1], outstream)
+ t = outstream.tempvar()
+ outstream.writeLine('llvm_filter_out(%s %s %s)' % (t, source, out))
+ return _deref(t)
+ if e.__class__ == functions.FilterFunction:
+ source = generate_Expansion(e._arguments[0], outstream)
+ out = generate_Expansion(e._arguments[1], outstream)
+ t = outstream.tempvar()
+ outstream.writeLine('llvm_filter(%s %s %s)' % (t, source, out))
+ return _deref(t)
+ if e.__class__ == functions.FindstringFunction:
+ needle = generate_Expansion(e._arguments[0], outstream)
+ haystack = generate_Expansion(e._arguments[1], outstream)
+ t = outstream.tempvar()
+ outstream.writeLine('string(FIND "%s" "%s" %s)' % (haystack, needle, t))
+ return _deref(t)
+
+ raise RuntimeError("Unknown expansion class: %s" % e.__class__)
+
+def generate_Condition(cond, dirname, outstream, elseif):
+ if cond.__class__ == EqCondition:
+ s = "if(" if not elseif else "elseif("
+ s += "\"" if cond.expected else "NOT \""
+ # FIXME: Do proper coercion to string.
+ s += generate_Expansion(cond.exp1, outstream)
+ s += "\" STREQUAL \""
+ s += generate_Expansion(cond.exp2, outstream)
+ s += "\")"
+ outstream.writeLine(s)
+ outstream.indent(2)
+ return
+ if cond.__class__ == IfdefCondition:
+ assert not elseif
+ s = "if("
+ if not cond.expected:
+ s += "NOT "
+ s += "DEFINED "
+ s += generate_Expansion(cond.exp, outstream)
+ s += ")"
+ outstream.writeLine(s)
+ outstream.indent(2)
+ return
+ if cond.__class__ == ElseCondition:
+ outstream.writeLine("else()")
+ outstream.indent(2)
+ return
+
+ raise RuntimeError("Unknown condition! %s" % cond.__class__)
+
+def generate_SetVariable(cmd, dirname, outstream):
+ d = Data.fromstring(cmd.value, cmd.valueloc)
+ e, t, o = parsemakesyntax(d, 0, (), parser.iterdata)
+
+ name = generate_Expansion(cmd.vnameexp, outstream)
+ exp = generate_Expansion(e, outstream)
+ if '+' in cmd.token:
+ outstream.writeLine("list(APPEND %s %s)" % (name, exp))
+ else:
+ outstream.writeLine("set(%s %s)" % (name, exp))
+
+def generate_ConditionBlock(cmd, dirname, outstream):
+ elseif = False
+ for c, statements in cmd._groups:
+ generate_Condition(c, dirname, outstream, elseif)
+ elseif = True
+ _generate(dirname, statements, outstream)
+ outstream.indent(-2)
+ outstream.writeLine("endif()")
+
+def generate_Rule(cmd, dirname, outstream):
+ # Burg adds rules for flex/bison. We'll have to add that ourselves.
+ if 'Burg' in dirname or 'gawk' in dirname:
+ return
+ # Lua and sqlite generate input. Have to add that ourselves.
+ elif 'lua' in dirname or 'sqlite' in dirname or 'pcompress' in dirname or 'consumer-typeset' in dirname:
+ return
+ # FIXME: support 'clean' rules!
+ elif 'JM' in dirname or 'kimwitu++' in dirname or 'mafft' in dirname:
+ pass
+ elif 'rawdaudio' in dirname:
+ # Rawdaudio just has an empty all rule :/
+ return
+ else:
+ raise RuntimeError("Creating a rule?!")
+
+def ignore(cmd, dirname, outstream):
+ pass
+
+dispatchtable = {
+ SetVariable: generate_SetVariable,
+ ConditionBlock: generate_ConditionBlock,
+ Rule: generate_Rule,
+ Include: ignore,
+ Command: ignore,
+ EmptyDirective: ignore
+}
+
+extra_cmake = {
+ 'Burg': '''
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+add_yacc_parser(burg_parser gram.y ${CMAKE_CURRENT_BINARY_DIR}/y.tab.c ${CMAKE_CURRENT_BINARY_DIR}/y.tab.h)
+ ''',
+ 'gawk': '''
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+add_yacc_parser(gawk_parser awk.y ${CMAKE_CURRENT_BINARY_DIR}/awk.tab.c ${CMAKE_CURRENT_BINARY_DIR}/awk.tab.h)
+ ''',
+ 'lua': '''
+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 -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}/input ${CMAKE_CURRENT_BINARY_DIR}
+ COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/*.lua ${CMAKE_CURRENT_BINARY_DIR}
+ COMMAND ${CMAKE_CURRENT_BINARY_DIR}/generate_inputs.sh
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ COMMENT "Generating lua test inputs")
+add_custom_target(lua_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/generate_inputs.sh)
+ ''',
+ 'sqlite3': '''
+if(SMALL_PROBLEM_SIZE)
+ set(SQLITE_INPUTNAME smalltest)
+else()
+ set(SQLITE_INPUTNAME speedtest)
+endif()
+add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/test15.sql
+ COMMAND ${TCL_TCLSH} ${CMAKE_CURRENT_SOURCE_DIR}/${SQLITE_INPUTNAME}.tcl
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ COMMENT "Generating sqlite test inputs")
+add_custom_target(sqlite_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/test15.sql)
+ ''',
+ 'pcompress2': '''
+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})
+ ''',
+ 'consumer-typeset': '''
+add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/data/hyph
+ COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/data/hyph
+ COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/data/hyph/* ${CMAKE_CURRENT_BINARY_DIR}/data/hyph
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ COMMENT "Copying consumer-typeset test inputs")
+add_custom_target(consumer-typeset_input SOURCES ${CMAKE_CURRENT_BINARY_DIR}/data/hyph)
+ ''',
+ 'nbench': '''
+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)
+ '''
+}
+
+late_extra_cmake = {
+ 'lua': 'add_dependencies(lua lua_input)',
+ 'sqlite3': 'add_dependencies(sqlite3 sqlite_input)',
+ 'pcompress2': 'add_dependencies(pcompress2 pcompress2_input)',
+ 'consumer-typeset': 'add_dependencies(consumer-typeset consumer-typeset_input)',
+ 'nbench': 'add_dependencies(nbench nbench_input)'
+}
+
+def _generate(dirname, commands, outstream):
+ for c in commands:
+ if c.__class__ in dispatchtable:
+ dispatchtable[c.__class__](c, dirname, outstream)
+ else:
+ raise RuntimeError("Unknown command: %s" % c.__class__)
+
+def generate(dirname, commands, macro=None):
+ fh = open(os.path.join(dirname, 'CMakeLists.txt'), 'w')
+ fh.write("""# Autogenerated from %s
+
+set(DIRS)
+set(PARALLEL_DIRS)
+
+""" % (os.path.join(dirname, 'Makefile'),))
+
+ s = Stream()
+ _generate(dirname, commands, s)
+ fh.write(s.str())
+
+ if os.path.basename(dirname) in extra_cmake:
+ fh.write(extra_cmake[os.path.basename(dirname)])
+ if macro:
+ fh.write("%s()\n" % macro)
+ if os.path.basename(dirname) in late_extra_cmake:
+ fh.write(late_extra_cmake[os.path.basename(dirname)])
+
+ fh.write("""
+llvm_add_subdirectories(${DIRS} ${PARALLEL_DIRS})
+""")
+
+def visitSingleSource(dirname):
+ files = os.listdir(os.path.abspath(dirname))
+
+ for filename in files:
+ absfilename = os.path.join(dirname, filename)
+ if filename == "Makefile":
+ print "parsing %s/%s..." % (dirname, filename)
+ commands = parsefile(absfilename)
+ print "generating %s/CMakeLists.txt" % (dirname,)
+ generate(dirname, commands, "llvm_singlesource")
+
+ for filename in files:
+ absfilename = os.path.join(dirname, filename)
+ if os.path.isdir(absfilename):
+ visitSingleSource(absfilename)
+
+def visitMultiSource(dirname):
+ files = os.listdir(os.path.abspath(dirname))
+
+ for filename in files:
+ absfilename = os.path.join(dirname, filename)
+ if filename == "Makefile":
+ print "parsing %s/%s..." % (dirname, filename)
+ commands = parsefile(absfilename)
+ print "generating %s/CMakeLists.txt" % (dirname,)
+ generate(dirname, commands, "llvm_multisource")
+
+
+ for filename in files:
+ absfilename = os.path.join(dirname, filename)
+ if os.path.isdir(absfilename):
+ visitMultiSource(absfilename)
+
+if __name__ == "__main__":
+ visitSingleSource('SingleSource')
+ visitMultiSource('MultiSource')
+
Index: cmake/lit-test-template.in
===================================================================
--- /dev/null
+++ cmake/lit-test-template.in
@@ -0,0 +1,3 @@
+; RUN: ${RUNUNDER} ${CMAKE_SOURCE_DIR}/RunSafely.sh -t ${TIMEIT} 7200 ${STDIN_FILENAME} %t ${CMAKE_CURRENT_BINARY_DIR}/${exename} ${RUN_OPTIONS}
+; RUN: ${PROGRAM_OUTPUT_FILTER} %t
+; RUN: ${DIFFPROG} %t ${REFERENCE_OUTPUT}
Index: cmake/modules/DetectArchitecture.c
===================================================================
--- /dev/null
+++ cmake/modules/DetectArchitecture.c
@@ -0,0 +1,23 @@
+#if defined(__aarch64__)
+const char *str = "ARCHITECTURE IS AArch64";
+#elif defined(__arm__)
+const char *str = "ARCHITECTURE IS ARM";
+#elif defined(__alpha__)
+const char *str = "ARCHITECTURE IS Alpha";
+#elif defined(__mips__)
+const char *str = "ARCHITECTURE IS Mips";
+#elif defined(__powerpc__) || defined(__ppc__) || defined(__power__)
+const char *str = "ARCHITECTURE IS PowerPC";
+#elif defined(__sparc__)
+const char *str = "ARCHITECTURE IS Sparc";
+#elif defined(__xcore__)
+const char *str = "ARCHITECTURE IS XCore";
+#elif defined(__i386__) || defined(__x86_64__)
+const char *str = "ARCHITECTURE IS x86";
+#endif
+
+int main(int argc, char **argv) {
+ int require = str[argc];
+ (void)argv;
+ return require;
+}
Index: cmake/modules/DetectArchitecture.cmake
===================================================================
--- /dev/null
+++ cmake/modules/DetectArchitecture.cmake
@@ -0,0 +1,35 @@
+##===- DetectArchitecture.cmake -------------------------------------------===##
+#
+# Performs a try_compile to determine the architecture of the target.
+#
+##===----------------------------------------------------------------------===##
+
+macro(detect_architecture variable)
+ try_compile(HAVE_${variable}
+ ${CMAKE_BINARY_DIR}
+ ${CMAKE_SOURCE_DIR}/cmake/modules/DetectArchitecture.c
+ OUTPUT_VARIABLE OUTPUT
+ COPY_FILE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/DetectArchitecture.bin)
+
+ if(HAVE_${variable})
+ file(STRINGS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/DetectArchitecture.bin
+ DETECT_ARCH_STRING LIMIT_COUNT 1 REGEX "ARCHITECTURE IS")
+ if(DETECT_ARCH_STRING)
+ string(REGEX MATCH "[^ ]*$" DETECT_ARCH_MATCH ${DETECT_ARCH_STRING})
+ if(DETECT_ARCH_MATCH)
+ message(STATUS "Check target system architecture: ${DETECT_ARCH_MATCH}")
+ set(${variable} ${DETECT_ARCH_MATCH})
+ else()
+ message(SEND_ERROR "Could not detect target system architecture!")
+ endif()
+ else()
+ message(SEND_ERROR "Could not detect target system architecture!")
+ endif()
+ else()
+ message(STATUS "Determine the system architecture - failed")
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+ "Determining the system architecture fialed with the following output:\n${OUTPUT}")
+ set(${variable})
+ endif()
+
+endmacro(detect_architecture)
\ No newline at end of file
Index: cmake/modules/FindYACC.cmake
===================================================================
--- /dev/null
+++ cmake/modules/FindYACC.cmake
@@ -0,0 +1,24 @@
+##===- FindYACC.cmake -----------------------------------------------------===##
+#
+# Defines custom rules for building a YACC parser. Based on FindBISON.cmake.
+#
+##===----------------------------------------------------------------------===##
+
+find_program(YACC_EXECUTABLE yacc DOC "Path to the YACC executable")
+mark_as_advanced(YACC_EXECUTABLE)
+
+if(YACC_EXECUTABLE)
+
+ macro(add_yacc_parser target_name input_grammar output_c output_h)
+ add_custom_command(OUTPUT ${output_c} ${output_h}
+ COMMAND ${YACC_EXECUTABLE}
+ ARGS -d -o ${output_c} ${input_grammar}
+ DEPENDS ${input_grammar}
+ COMMENT "Building YACC parser ${output_c}"
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+ endmacro(add_yacc_parser)
+
+endif(YACC_EXECUTABLE)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(YACC DEFAULT_MSG YACC_EXECUTABLE)
Index: cmake/modules/MakefileFunctions.cmake
===================================================================
--- /dev/null
+++ cmake/modules/MakefileFunctions.cmake
@@ -0,0 +1,46 @@
+##===- MakefileFunctions.cmake --------------------------------------------===##
+#
+# Defines functions used within subdirectory CMakeLists.txt, that look a bit
+# like standard GNU Make functions. These support the auto-generation of
+# CMakeLists.txt from Makefiles, although any use of these should probably be
+# looked at and manually translated into more idiomatic CMake.
+#
+##===----------------------------------------------------------------------===##
+
+# llvm_add_subdirectories - wrapper around add_subdirectory that can take
+# multiple items.
+macro(llvm_add_subdirectories)
+ foreach(V ${ARGV})
+ add_subdirectory(${V})
+ endforeach(V)
+endmacro()
+
+# llvm_prepend - equivalent to $(addprefix var,prefix). Modifies var in place.
+function(llvm_prepend var prefix)
+ set(listVar "")
+ foreach(f ${ARGN})
+ list(APPEND listVar "${prefix}${f}")
+ endforeach(f)
+ set(${var} "${listVar}" PARENT_SCOPE)
+endfunction()
+
+# llvm_filter - equivalent to $(filter needle,haystack). Returns a list containing
+# all of the items in ${ARGN} (after needle) that match needle.
+macro(llvm_filter output needle)
+ set(${output})
+ foreach(haystack_item ${ARGN})
+ foreach(needle_item ${needle})
+ if("${haystack_item}" STREQUAL "${needle_item}")
+ list(APPEND ${output} ${haystack_item})
+ endif()
+ endforeach()
+ endforeach()
+endmacro()
+
+# llvm_filter_out - equivalent to $(filter-out needle,haystack). Inverse of
+# llvm_filter.
+macro(llvm_filter_out output needle)
+ set(${output} "${ARGN}")
+ llvm_filter(tmp_output ${needle} ${ARGN})
+ list(REMOVE_ITEM ${output} ${tmp_output})
+endmacro()
Index: cmake/modules/SingleMultiSource.cmake
===================================================================
--- /dev/null
+++ cmake/modules/SingleMultiSource.cmake
@@ -0,0 +1,192 @@
+##===- SingleMultiSource.cmake --------------------------------------------===##
+#
+# Defines helpers to add executables and tests. The entry points to this
+# file are:
+# `llvm_singlesource()` and
+# `llvm_multisource()`
+#
+# Each is a macro that uses the environment it was called in to determine
+# what to build and how, and generates a test file that can be given to LIT.
+# The test file is generated at configure time.
+#
+##===----------------------------------------------------------------------===##
+
+# get_unique_exe_name - Given a source file name after which a test should be
+# named, create a unique name for the test. Usually this is just the source file
+# with the suffix stripped, but in some cases this ends up causing duplicates
+# so attempt to make each unique (by adding pathname segments until they become
+# unique).
+#
+# FIXME: Swap this with a simpler procedure to just append a numeral
+set_property(GLOBAL PROPERTY registered_executables)
+function(get_unique_exe_name new_name main_src)
+ get_property(registered_executables GLOBAL PROPERTY registered_executables)
+
+ string(REGEX REPLACE ".[cp]+$" "" path ${main_src})
+ string(REGEX REPLACE ".*/" "" name ${path})
+ list(FIND registered_executables ${name} name_idx)
+
+ if(${name_idx} EQUAL -1)
+ set(${new_name} ${name} PARENT_SCOPE)
+ set_property(GLOBAL APPEND PROPERTY registered_executables ${name})
+ return()
+ endif()
+
+ # There is a clash. Rename the target. Each time around the loop pull in
+ # a new path component.
+ foreach(n RANGE 1 4)
+ string(REGEX REPLACE ".*/([^/]+/${name})" "\\1" name ${path})
+ string(REGEX REPLACE "/" "-" safe_name ${name})
+
+ list(FIND registered_executables ${safe_name} name_idx)
+ if(${name_idx} EQUAL -1)
+ set(${new_name} ${safe_name} PARENT_SCOPE)
+ set_property(GLOBAL APPEND PROPERTY registered_executables ${safe_name})
+ return()
+ endif()
+ endforeach()
+ message(FATAL_ERROR "Failed to uniquify executable name!")
+endfunction()
+
+# append_cflags - add flags to the CFLAGS for target.
+macro(append_cflags target flags)
+ if(NOT "${${flags}}" STREQUAL "")
+ get_target_property(old_cflags ${target} COMPILE_FLAGS)
+ if(${old_cflags} STREQUAL "old_cflags-NOTFOUND")
+ set(old_cflags)
+ endif()
+ string(REPLACE ";" " " s "${old_cflags};${${flags}}")
+ set_target_properties(${target} PROPERTIES COMPILE_FLAGS ${s})
+ endif()
+endmacro()
+
+# append_ldflags - add flags to the LDFLAGS for target.
+macro(append_ldflags target flags)
+ if(NOT "${${flags}}" STREQUAL "")
+ get_target_property(old_ldflags ${target} LINK_FLAGS)
+ if(${old_ldflags} STREQUAL "old_ldflags-NOTFOUND")
+ set(old_ldflags)
+ endif()
+ string(REPLACE ";" " " s "${old_ldflags};${${flags}}")
+ set_target_properties(${target} PROPERTIES LINK_FLAGS ${s})
+ endif()
+endmacro()
+
+# llvm_add_test - Create a .test driver file suitable for LIT.
+#
+# The test template lives in cmake/lit-test-template.in and is configured by this function.
+function(llvm_add_test name exename)
+ if(NOT DEFINED STDIN_FILENAME)
+ set(STDIN_FILENAME /dev/null)
+ endif()
+
+ # Hash if we've been asked to, otherwise just use "touch" as an identity function.
+ if(HASH_PROGRAM_OUTPUT)
+ set(PROGRAM_OUTPUT_FILTER ${CMAKE_SOURCE_DIR}/HashProgramOutput.sh)
+ else()
+ set(PROGRAM_OUTPUT_FILTER touch)
+ endif()
+
+ # Find the reference output file key name.
+ if(SMALL_PROBLEM_SIZE)
+ set(KEY small)
+ elseif(LARGE_PROBLEM_SIZE)
+ set(KEY large)
+ else()
+ set(KEY)
+ endif()
+
+ # Pick the best reference output based on "programname.reference_output".
+ if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${KEY})
+ set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${KEY})
+ elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${KEY})
+ set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${KEY})
+ elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian)
+ set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian)
+ elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output)
+ set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output)
+ else()
+ # Just compare to its own output. This will always succeed, but here's hoping the
+ # test in question uses its exit value to determine status, so it'll be caught by
+ # the previous RUN line.
+ set(REFERENCE_OUTPUT "%t")
+ message("-- No reference output found for test ${name}")
+ endif()
+
+ # If the program is nondeterministic, don't bother diffing and use "touch" again as an identity.
+ if(DEFINED PROGRAM_IS_NONDETERMINISTIC)
+ set(DIFFPROG touch)
+ else()
+ set(DIFFPROG ${CMAKE_BINARY_DIR}/tools/fpcmp)
+ if(DEFINED FP_TOLERANCE)
+ set(DIFFPROG "${DIFFPROG} -r ${FP_TOLERANCE}")
+ endif()
+ if(DEFINED FP_ABSTOLERANCE)
+ set(DIFFPROG "${DIFFPROG} -a ${FP_ABSTOLERANCE}")
+ endif()
+ endif()
+
+ if(DEFINED RUN_OPTIONS)
+ # RUN_OPTIONS is a semicolon-separated list. Change it into a whitespace-separated string.
+ string(REPLACE ";" " " RUN_OPTIONS "${RUN_OPTIONS}")
+ endif()
+
+ # FIXME: Sort out how to call timeit, or timeit.sh.
+ set(TIMEIT ${CMAKE_BINARY_DIR}/tools/timeit)
+ # FIXME: Add runtimelimit support.
+
+ # Now do the actual configuration.
+ configure_file(${CMAKE_SOURCE_DIR}/cmake/lit-test-template.in
+ ${CMAKE_CURRENT_BINARY_DIR}/${exename}.test)
+endfunction()
+
+# llvm_singlesource - configure the current directory as a SingleSource subdirectory -
+# i.e. every file in *.{c,cpp,cc} is treated as its own test.
+macro(llvm_singlesource)
+ file(GLOB sources *.c *.cpp *.cc)
+ foreach(source ${sources})
+ # Find the pure name of the test
+ string(REGEX REPLACE ".[cp]+$" "" path ${source})
+ string(REGEX REPLACE ".*/" "" name ${path})
+
+ # Should we skip this?
+ list(FIND PROGRAMS_TO_SKIP ${name} name_idx)
+ if(${name_idx} EQUAL -1)
+ get_unique_exe_name(source_exename ${source})
+ add_executable(${source_exename} ${source})
+ append_cflags(${source_exename} CFLAGS)
+ append_cflags(${source_exename} CPPFLAGS)
+ append_cflags(${source_exename} CXXFLAGS)
+ append_ldflags(${source_exename} LDFLAGS)
+ llvm_add_test(${name} ${source_exename})
+ endif()
+ endforeach()
+endmacro()
+
+# llvm_multisource - configure the current directory as a MultiSource subdirectory -
+# i.e. there is one test and it consists of all sources in the directory (or a curated
+# list, if Source is defined).
+macro(llvm_multisource)
+ if(DEFINED Source)
+ set(sources ${Source})
+ else()
+ file(GLOB sources *.c *.cpp *.cc)
+ endif()
+ list(LENGTH sources sources_len)
+
+ if(sources_len GREATER 0 AND DEFINED PROG)
+ # Should we skip this?
+ list(FIND PROGRAMS_TO_SKIP ${PROG} name_idx)
+ if(${name_idx} EQUAL -1)
+ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+ include_directories(${CMAKE_CURRENT_BINARY_DIR})
+ get_unique_exe_name(source_exename "${PROG}.c")
+ add_executable(${source_exename} ${sources})
+ append_cflags(${source_exename} CFLAGS)
+ append_cflags(${source_exename} CPPFLAGS)
+ append_cflags(${source_exename} CXXFLAGS)
+ append_ldflags(${source_exename} LDFLAGS)
+ llvm_add_test(${PROG} ${source_exename})
+ endif()
+endif()
+endmacro()
Index: lit.cfg
===================================================================
--- /dev/null
+++ lit.cfg
@@ -0,0 +1,46 @@
+import lit.formats
+import lit
+import os, glob, re
+
+def getUserTimeFromTimeOutput(f):
+ with open(f) as fd:
+ l = [l for l in fd.readlines()
+ if l.startswith('user')]
+ assert len(l) == 1
+
+ m = re.match(r'user\s+([0-9.]+)', l[0])
+ return float(m.group(1))
+
+class TestSuiteTest(lit.formats.ShTest):
+ def __init__(self):
+ lit.formats.ShTest.__init__(self, False)
+
+ def execute(self, test, litConfig):
+ result = lit.formats.ShTest.execute(self, test, litConfig)
+ basepath = os.path.dirname(test.getFilePath())
+
+ if not result.code.isFailure:
+ # Collect the timing information.
+ timeglob = os.path.join(basepath, 'Output', '*.time')
+ times = glob.glob(timeglob)
+ assert len(times) == 1
+ time = getUserTimeFromTimeOutput(times[0])
+
+ result.addMetric('exec_time', lit.Test.toMetricValue(time))
+
+ # For completeness, attempt to find compile time information too.
+ compile_time = 0.0
+ for path, subdirs, files in os.walk(basepath):
+ for file in files:
+ if file.endswith('.o.time'):
+ compile_time += getUserTimeFromTimeOutput(os.path.join(path, file))
+ result.addMetric('compile_time', lit.Test.toMetricValue(compile_time))
+
+ return result
+
+config.name = 'test-suite'
+
+config.test_format = TestSuiteTest()
+config.suffixes = ['.test']
+config.test_source_root = os.path.dirname(__file__)
+config.excludes = ['ABI-Testsuite']
Index: tools/CMakeLists.txt
===================================================================
--- /dev/null
+++ tools/CMakeLists.txt
@@ -0,0 +1,5 @@
+
+# FIXME: These need to be host-compiled, if we're cross compiling.
+# FIXME: Replicate Makefile.tools's logic for determining whether to use fpcmp/fpcmp.sh
+add_executable(fpcmp fpcmp.c)
+add_executable(timeit timeit.c)