MegaGlest/mk/cmake/Modules/SpecialMacros.cmake

# special macros SpecialMacros.cmake

include(CheckFunctionExists)
include(AddFileDependencies)

#macro(special_add_library lib)
#  if (WIN32)
#    add_library(${lib} STATIC ${ARGN})
#  else (WIN32)
#    add_library(${lib} SHARED ${ARGN})
#  endif (WIN32)
#endmacro(special_add_library)

macro(special_check_for_sse _max_sse_level_desired) 
  set(${_max_sse_level_desired})
  
  message(STATUS "Max SSE desired: [${_max_sse_level_desired}]")

  # check for SSE extensions
  include(CheckCXXSourceRuns)
  include(CheckCSourceRuns)

  # Add MSVC to stop flags being added to msbuild.
  IF(NOT MINGW)
    set(SSE_FLAGS)
  
    set(CMAKE_REQUIRED_FLAGS "-msse3")
    check_cxx_source_runs("
    #include <pmmintrin.h>
  
    int main()
    {
        __m128d a, b;
        double vals[2] = {0};
        a = _mm_loadu_pd(vals);
        b = _mm_hadd_pd(a,a);
        _mm_storeu_pd(vals, b);
        return 0;
    }"
    HAS_SSE3_EXTENSIONS)
  
    set(CMAKE_REQUIRED_FLAGS "-msse2")
    check_cxx_source_runs("
    #include <emmintrin.h>
  
    int main()
    {
        __m128d a, b;
        double vals[2] = {0};
        a = _mm_loadu_pd(vals);
        b = _mm_add_pd(a,a);
        _mm_storeu_pd(vals,b);
        return 0;
      }"
      HAS_SSE2_EXTENSIONS)
  
    set(CMAKE_REQUIRED_FLAGS "-msse")
    check_cxx_source_runs("
    #include <xmmintrin.h>
    int main()
    {
        __m128 a, b;
        float vals[4] = {0};
        a = _mm_loadu_ps(vals);
        b = a;
        b = _mm_add_ps(a,b);
        _mm_storeu_ps(vals,b);
        return 0;
    }"
    HAS_SSE_EXTENSIONS)
  
    set(CMAKE_REQUIRED_FLAGS)
    
    if(HAS_SSE3_EXTENSIONS AND (${_max_sse_level_desired} MATCHES "3"))
      set(SSE_FLAGS "-msse3")
      IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?Clang")
      ELSE()
              set(SSE_FLAGS "${SSE_FLAGS} -mfpmath=sse")
      ENDIF()
      IF(NOT MSVC)
        message(STATUS "Found SSE3 extensions, using flags: ${SSE_FLAGS}")
      ELSE()
        message(STATUS "Found SSE3 extensions.")
      ENDIF()
    elseif(HAS_SSE2_EXTENSIONS AND (${_max_sse_level_desired} MATCHES "2" OR ${_max_sse_level_desired} MATCHES "3"))
      set(SSE_FLAGS "-msse2")
      IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?Clang")
      ELSE()
              set(SSE_FLAGS "${SSE_FLAGS} -mfpmath=sse")
      ENDIF()

      IF(NOT MSVC)
        message(STATUS "Found SSE2 extensions, using flags: ${SSE_FLAGS}")
      ELSE()
        message(STATUS "Found SSE2 extensions.")
      ENDIF()
    elseif(HAS_SSE_EXTENSIONS AND (${_max_sse_level_desired} MATCHES "1" OR ${_max_sse_level_desired} MATCHES "2" OR ${_max_sse_level_desired} MATCHES "3"))
          set(SSE_FLAGS "-msse")
          IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?Clang")
          ELSE()
                  set(SSE_FLAGS "${SSE_FLAGS} -mfpmath=sse")
          ENDIF()
          IF(NOT MSVC)
            message(STATUS "Found SSE extensions, using flags: ${SSE_FLAGS}")
          ELSE()
            message(STATUS "Found SSE extensions.")
          ENDIF()
    endif()
    
    IF(NOT MSVC)
      add_definitions(${SSE_FLAGS})
    ENDIF()

  elseif(MSVC) #todo: remove this unused check for SSE.
    check_cxx_source_runs("
      #include <emmintrin.h>
    
      int main()
      {
          __m128d a, b;
          double vals[2] = {0};
          a = _mm_loadu_pd(vals);
          b = _mm_add_pd(a,a);
          _mm_storeu_pd(vals,b);
          return 0;
      }"
      HAS_SSE2_EXTENSIONS)
    if( HAS_SSE2_EXTENSIONS AND (NOT ${_max_sse_level_desired} OR ${_max_sse_level_desired} MATCHES "2"))
      message(STATUS "Found SSE2 extensions")
      set(SSE_FLAGS "/arch:SSE2 /fp:fast -D__SSE__ -D__SSE2__" )
    endif()
    
    add_definitions(${SSE_FLAGS})
  endif()
endmacro(special_check_for_sse)

macro(special_check_for_x87) 
  # check for X87 support
  include(CheckCXXSourceRuns)
  include(CheckCSourceRuns)

  if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
  
   IF(NOT MINGW)
           check_cxx_source_runs("
            int main()
            {
               unsigned short fpu_mode;
               do { asm volatile (\"fstcw %0\" : \"=m\" (fpu_mode) : ); } while (0);
               fpu_mode &= 0xFCFF; 
               do { asm volatile (\"fclex \\\\n fldcw %0\" : : \"m\" (fpu_mode)); } while (0);

               return 0;
            }"
            HAS_X87_SUPPORT)
   ELSE()
        set(HAS_X87_SUPPORT On)
   ENDIF()
  
   if(HAS_X87_SUPPORT)
    message(STATUS "Found X87 support.")
   endif()

  elseif(MSVC)

    set(HAS_X87_SUPPORT On)

  endif()
endmacro(special_check_for_x87)

macro(special_add_compile_flags target)
  set(args ${ARGN})
  separate_arguments(args)
  get_target_property(_flags ${target} COMPILE_FLAGS)
  if(NOT _flags)
    set(_flags ${ARGN})
  else(NOT _flags)
    separate_arguments(_flags)
    list(APPEND _flags "${args}")
  endif(NOT _flags)

  _special_list_to_string(_flags_str "${_flags}")
  set_target_properties(${target} PROPERTIES
                        COMPILE_FLAGS "${_flags_str}")
endmacro(special_add_compile_flags)

macro(special_add_link_flags target)
  set(args ${ARGN})
  separate_arguments(args)
  get_target_property(_flags ${target} LINK_FLAGS)
  if(NOT _flags)
    set(_flags ${ARGN})
  else(NOT _flags)
    separate_arguments(_flags)
    list(APPEND _flags "${args}")
  endif(NOT _flags)

  _special_list_to_string(_flags_str "${_flags}")
  set_target_properties(${target} PROPERTIES
                        LINK_FLAGS "${_flags_str}")
endmacro(special_add_link_flags)

macro(_special_list_to_string _string _list)
    set(${_string})
    foreach(_item ${_list})
        string(LENGTH "${${_string}}" _len)
        if(${_len} GREATER 0)
          set(${_string} "${${_string}} ${_item}")
        else(${_len} GREATER 0)
          set(${_string} "${_item}")
        endif(${_len} GREATER 0)
    endforeach(_item)
endmacro(_special_list_to_string)