forked from OSchip/llvm-project
261 lines
11 KiB
CMake
261 lines
11 KiB
CMake
#
|
|
#//===----------------------------------------------------------------------===//
|
|
#//
|
|
#// The LLVM Compiler Infrastructure
|
|
#//
|
|
#// This file is dual licensed under the MIT and the University of Illinois Open
|
|
#// Source Licenses. See LICENSE.txt for details.
|
|
#//
|
|
#//===----------------------------------------------------------------------===//
|
|
#
|
|
|
|
####################################### FUNCTIONS/MACROS ###########################################
|
|
# It should be noted that in cmake, functions can only be used on a single line with the return value
|
|
# stored in a parameter you send to the function. There isn't a true return value. So technically,
|
|
# all functions would have a C/C++ prototype of:
|
|
# void function_name(parameter1, parameter2, ...);
|
|
#
|
|
# If you want a return value, you have to use a parameter so the function prototype would be:
|
|
# void function_name(input_parameter1, input_parameter2, ..., return_value)
|
|
# ##################
|
|
|
|
# void say(string message_to_user);
|
|
# - prints out message_to_user
|
|
macro(say message_to_user)
|
|
message(STATUS "${message_to_user}")
|
|
endmacro()
|
|
|
|
# void warning_say(string message_to_user);
|
|
# - prints out message_to_user with a warning
|
|
macro(warning_say message_to_user)
|
|
message(WARNING "${message_to_user}")
|
|
endmacro()
|
|
|
|
# void error_say(string message_to_user);
|
|
# - prints out message_to_user with an error and exits cmake
|
|
macro(error_say message_to_user)
|
|
message(FATAL_ERROR "${message_to_user}")
|
|
endmacro()
|
|
|
|
# void debug_say(string message_to_developer);
|
|
# - prints out message when GLOBAL_DEBUG == 1 (for debugging cmake build)
|
|
macro(debug_say message_to_developer)
|
|
if(${GLOBAL_DEBUG} STREQUAL "1")
|
|
say("DEBUG: ${message_to_developer}")
|
|
endif()
|
|
endmacro()
|
|
|
|
# void debug_say_var(variable var);
|
|
# - prints the variable name and its value (for debugging cmake build)
|
|
macro(debug_say_var var)
|
|
if(${GLOBAL_DEBUG} STREQUAL "1")
|
|
say("DEBUG: Variable: ${var} = ${${var}} ")
|
|
endif()
|
|
endmacro()
|
|
|
|
# void set_legal_arch(string* return_arch_string);
|
|
# - returns (through return_arch_string) the formal architecture
|
|
# string or warns user of unknown architecture
|
|
function(set_legal_arch return_arch_string)
|
|
if(${IA32})
|
|
set(${return_arch_string} "IA-32" PARENT_SCOPE)
|
|
elseif(${INTEL64})
|
|
set(${return_arch_string} "Intel(R) 64" PARENT_SCOPE)
|
|
elseif(${MIC})
|
|
set(${return_arch_string} "Intel(R) Many Integrated Core Architecture" PARENT_SCOPE)
|
|
elseif(${LIBOMP_ARCH} STREQUAL "l1")
|
|
set(${return_arch_string} "L1OM" PARENT_SCOPE)
|
|
elseif(${ARM})
|
|
set(${return_arch_string} "ARM" PARENT_SCOPE)
|
|
elseif(${PPC64BE})
|
|
set(${return_arch_string} "PPC64BE" PARENT_SCOPE)
|
|
elseif(${PPC64LE})
|
|
set(${return_arch_string} "PPC64LE" PARENT_SCOPE)
|
|
elseif(${AARCH64})
|
|
set(${return_arch_string} "AARCH64" PARENT_SCOPE)
|
|
else()
|
|
warning_say("set_legal_arch(): Warning: Unknown architecture...")
|
|
endif()
|
|
endfunction()
|
|
|
|
# void check_variable(string var, string var_name, list<string>values_list);
|
|
# - runs through values_list checking if ${var} == values_list[i] for any i.
|
|
# - if the var is found, then just print it out
|
|
# - if the var is not found, then warn user
|
|
function(check_variable var values_list)
|
|
set(valid_flag 0)
|
|
foreach(value IN LISTS values_list)
|
|
if("${${var}}" STREQUAL "${value}")
|
|
set(valid_flag 1)
|
|
set(the_value "${value}")
|
|
endif()
|
|
endforeach()
|
|
if(${valid_flag} EQUAL 0)
|
|
error_say("check_variable(): ${var} = ${${var}} is unknown")
|
|
endif()
|
|
endfunction()
|
|
|
|
# void _export_lib_dir(string export_dir, string platform, string suffix, string* return_value);
|
|
# - basically a special case for mac platforms where it adds '.thin' to the output lib directory
|
|
function(_export_lib_dir pltfrm return_value)
|
|
if(${MAC})
|
|
set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib.thin" PARENT_SCOPE)
|
|
else()
|
|
set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# void _export_lib_fat_dir(string export_dir, string platform, string suffix, string* return_value);
|
|
# - another mac specialty case for fat libraries.
|
|
# - this sets export_lib_fat_dir in the MAIN part of CMakeLists.txt
|
|
function(_export_lib_fat_dir pltfrm return_value)
|
|
set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# void get_build_number(string src_dir, string* return_build_number);
|
|
# - grab the eight digit build number (or 00000000) from kmp_version.c
|
|
function(get_build_number src_dir return_build_number)
|
|
# sets file_lines_list to a list of all lines in kmp_version.c
|
|
file(STRINGS "${src_dir}/src/kmp_version.c" file_lines_list)
|
|
|
|
# runs through each line in kmp_version.c
|
|
foreach(line IN LISTS file_lines_list)
|
|
# if the line begins with "#define KMP_VERSION_BUILD" then we take not of the build number
|
|
string(REGEX MATCH "^[ \t]*#define[ \t]+KMP_VERSION_BUILD" valid "${line}")
|
|
if(NOT "${valid}" STREQUAL "") # if we matched "#define KMP_VERSION_BUILD", then grab the build number
|
|
string(REGEX REPLACE "^[ \t]*#define[ \t]+KMP_VERSION_BUILD[ \t]+([0-9]+)" "\\1"
|
|
build_number "${line}"
|
|
)
|
|
endif()
|
|
endforeach()
|
|
set(${return_build_number} "${build_number}" PARENT_SCOPE) # return build number
|
|
endfunction()
|
|
|
|
# void set_legal_type(string* return_legal_type);
|
|
# - set the legal type name Performance/Profiling/Stub
|
|
function(set_legal_type return_legal_type)
|
|
if(${NORMAL_LIBRARY})
|
|
set(${return_legal_type} "Performance" PARENT_SCOPE)
|
|
elseif(${PROFILE_LIBRARY})
|
|
set(${return_legal_type} "Profiling" PARENT_SCOPE)
|
|
elseif(${STUBS_LIBRARY})
|
|
set(${return_legal_type} "Stub" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# void set_mac_os_new(bool* return_mac_os_new);
|
|
# - sets the return_mac_os_new variable to true or false based on macosx version
|
|
# - no real "cmakey" way to do this. Have to call execute_process()
|
|
function(set_mac_os_new return_mac_os_new)
|
|
execute_process(COMMAND "sw_vers" "-productVersion" OUTPUT_VARIABLE mac_osx_version)
|
|
if("${mac_osx_version}" VERSION_GREATER "10.6")
|
|
set(${return_mac_os_new} TRUE PARENT_SCOPE)
|
|
else()
|
|
set(${return_mac_os_new} FALSE PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# void add_prefix(string prefix, list<string>* list_of_items);
|
|
# - returns list_of_items with prefix prepended to all items
|
|
# - original list is modified
|
|
function(add_prefix prefix list_of_items)
|
|
set(local_list "")
|
|
foreach(item IN LISTS "${list_of_items}")
|
|
if(NOT "${item}" STREQUAL "")
|
|
list(APPEND local_list "${prefix}${item}")
|
|
endif()
|
|
endforeach()
|
|
set(${list_of_items} "${local_list}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# void add_suffix(string suffix, list<string>* list_of_items);
|
|
# - returns list_of_items with suffix appended to all items
|
|
# - original list is modified
|
|
function(add_suffix suffix list_of_items)
|
|
set(local_list "")
|
|
foreach(item IN LISTS "${list_of_items}")
|
|
if(NOT "${item}" STREQUAL "")
|
|
list(APPEND local_list "${item}${suffix}")
|
|
endif()
|
|
endforeach()
|
|
set(${list_of_items} "${local_list}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# void strip_suffix(list<string> list_of_items, list<string>* return_list);
|
|
# - returns a new list with suffix stripped (i.e., foo.c => foo)
|
|
# - list_of_items is not modified, return_list is modified
|
|
function(strip_suffix list_of_items return_list)
|
|
set(local_list "")
|
|
foreach(item IN LISTS "${list_of_items}")
|
|
if(NOT "${item}" STREQUAL "")
|
|
get_filename_component(filename "${item}" NAME_WE)
|
|
list(APPEND local_list "${filename}")
|
|
endif()
|
|
endforeach()
|
|
set(${return_list} "${local_list}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# void list_to_string(list<string> list_of_things, string* return_string);
|
|
# - converts a list to a space separated string
|
|
function(list_to_string list_of_things return_string)
|
|
string(REPLACE ";" " " output_variable "${list_of_things}")
|
|
set(${return_string} "${output_variable}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# void string_to_list(string str, list<string>* return_list);
|
|
# - converts a string to a semicolon separated list
|
|
# - what it really does is just string_replace all running whitespace to a semicolon
|
|
# - in cmake, a list is strings separated by semicolons: i.e., list of four items, list = "item1;item2;item3;item4"
|
|
function(string_to_list str return_list)
|
|
set(outstr)
|
|
string(REGEX REPLACE "[ \t]+" ";" outstr "${str}")
|
|
set(${return_list} "${outstr}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# void get_date(string* return_date);
|
|
# - returns the current date "yyyy-mm-dd hh:mm:ss UTC"
|
|
# - this function alone causes the need for CMake v2.8.11 (TIMESTAMP)
|
|
#function(get_date return_date)
|
|
# string(TIMESTAMP local_date "%Y-%m-%d %H:%M:%S UTC" UTC)
|
|
# set(${return_date} ${local_date} PARENT_SCOPE)
|
|
#endfunction()
|
|
|
|
# void find_a_program(string program_name, list<string> extra_paths, bool fail_on_not_found, string return_variable_name);
|
|
# - returns the full path of a program_name
|
|
# - first looks in the list of extra_paths
|
|
# - if not found in extra_paths, then look through system path
|
|
# - errors out if fail_on_not_found == true and cmake could not find program_name.
|
|
function(find_a_program program_name extra_paths fail_on_not_found return_variable_name)
|
|
# first try to find the program in the extra_paths
|
|
find_program(${return_variable_name} "${program_name}" PATHS "${extra_paths}" DOC "Path to ${program_name}" NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
|
|
if("${${return_variable_name}}" MATCHES NOTFOUND)
|
|
# if no extra_paths, or couldn't find it, then look in system $PATH
|
|
find_program(${return_variable_name} "${program_name}" DOC "Path to ${program_name}")
|
|
if("${${return_variable_name}}" MATCHES NOTFOUND AND ${fail_on_not_found})
|
|
error_say("Error: Could not find program: ${program_name}")
|
|
endif()
|
|
endif()
|
|
|
|
if(NOT "${${return_variable_name}}" MATCHES NOTFOUND)
|
|
say("-- Found ${program_name}: ${${return_variable_name}}")
|
|
endif()
|
|
|
|
set(${return_variable_name} ${${return_variable_name}} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# WINDOWS SPECIFIC
|
|
# void replace_md_with_mt(string flags_var)
|
|
# - This macro replaces the /MD compiler flags (Windows specific) with /MT compiler flags
|
|
# - This does nothing if no /MD flags were replaced.
|
|
macro(replace_md_with_mt flags_var)
|
|
set(flags_var_name ${flags_var}) # i.e., CMAKE_C_FLAGS_RELEASE
|
|
set(flags_var_value ${${flags_var}}) # i.e., "/MD /O2 ..."
|
|
string(REPLACE /MD /MT temp_out "${flags_var_value}")
|
|
string(COMPARE NOTEQUAL "${temp_out}" "${flags_var_value}" something_was_replaced)
|
|
if("${something_was_replaced}")
|
|
unset(${flags_var_name} CACHE)
|
|
set(${flags_var_name} ${temp_out} CACHE STRING "Replaced /MD with /MT compiler flags")
|
|
endif()
|
|
endmacro()
|
|
|