Commit cc524f71 authored by Atkins, Charles Vernon's avatar Atkins, Charles Vernon
Browse files

Merge branch 'upstream-dill' into fix-cmake-module-path-mangle 

# By dill Upstream
* upstream-dill:
  dill 2022-05-31 (54c88e34)
parents b8f9f7f3 67c67efd

thirdparty/dill/dill/.github/workflows/build-and-test.yml

0 → 100644
+119 −0
Original line number Diff line number Diff line 
name: Build and Test



on: 

  push: 

    branches: 

    - master 

  pull_request: 

    branches: 

    - master 



concurrency:

  group: ${{ github.head_ref || github.run_id }}

  cancel-in-progress: true



jobs:

  linux:

    # The jobs should run pretty quick; anything over 30m essentially means

    # someting is stuck somewhere

    timeout-minutes: 30

    runs-on: ubuntu-latest

    container: ${{ matrix.container }}

    env:

      GH_YML_JOBNAME: ${{ matrix.os }}-${{ matrix.compiler }}

      GH_YML_BUILDTYPE: ${{ matrix.buildtype }}

      GH_YML_SHA: ${{ github.event.pull_request.head.sha || github.sha }}



    strategy:

      fail-fast: false

      matrix:

        buildtype: [ release, debug ]

        os: [ centos7, alma8, ubuntu1604, ubuntu1804, ubuntu2004 ]

        compiler: [ clang, gcc, nvhpc ]

        exclude:

          - { os: alma8, compiler: nvhpc }

          - { os: ubuntu1604, compiler: nvhpc }

          - { os: ubuntu1804, compiler: nvhpc }

        include:

        - os: centos7

          container: centos:7

        - os: alma8

          container: almalinux:8

        - os: ubuntu1604

          container: ubuntu:16.04

        - os: ubuntu1804

          container: ubuntu:18.04

        - os: ubuntu2004

          container: ubuntu:20.04

        - os: centos7

          compiler: nvhpc

          container: nvcr.io/nvidia/nvhpc:21.2-devel-cuda11.2-centos7

        - os: ubuntu2004

          compiler: nvhpc

          container: nvcr.io/nvidia/nvhpc:21.2-devel-cuda11.2-ubuntu20.04



    steps:

    - uses: actions/checkout@v2

      with:

        ref: ${{ github.event.pull_request.head.sha }}

        path: source

    - name: Setup

      run: source/scripts/ci/setup/linux.sh

    - name: Update

      run: source/scripts/ci/gh-actions/run.sh update

    - name: Configure

      run: source/scripts/ci/gh-actions/run.sh configure

    - name: Build

      run: source/scripts/ci/gh-actions/run.sh build

    - name: Test

      run: source/scripts/ci/gh-actions/run.sh test



  mac_and_windows:

    # The jobs should run pretty quick; anything over 30m essentially means

    # someting is stuck somewhere

    timeout-minutes: 30

    runs-on: ${{ matrix.vm }}

    env:

      GH_YML_JOBNAME: ${{ matrix.jobname }}

      GH_YML_BUILDTYPE: ${{ matrix.buildtype }}

      GH_YML_SHA: ${{ github.event.pull_request.head.sha || github.sha }}



    strategy:

      fail-fast: false

      matrix:

        buildtype: [ release, debug ]

        jobname: [

          #windows2019-vs2019-clang,

          #windows2022-vs2022-msvc,

          macos-clang ]

        include:

        #- jobname: windows2019-vs2019-clang

        #  vm: windows-2019

        #- jobname: windows2022-vs2022-msvc

        #  vm: windows-2022

        - jobname: macos-clang

          vm: macos-latest



    defaults:

      run:

        shell: bash



    steps:

    - uses: actions/checkout@v2

      with:

        ref: ${{ github.event.pull_request.head.sha }}

        path: source

    - name: Setup

      if: ${{ runner.os == 'Windows' }}

      run: source/scripts/ci/setup/windows.sh

    - name: Setup

      if: ${{ runner.os == 'macOS' }}

      run: source/scripts/ci/setup/macos.sh

    - name: Update

      run: source/scripts/ci/gh-actions/run.sh update

    - name: Configure

      run: source/scripts/ci/gh-actions/run.sh configure

    - name: Build

      run: source/scripts/ci/gh-actions/run.sh build

    - name: Test

      run: source/scripts/ci/gh-actions/run.sh test

thirdparty/dill/dill/.github/workflows/triggers.yml

0 → 100644
+15 −0
Original line number Diff line number Diff line 
name: Triggers



on:

  workflow_run:

    workflows: ["Build and Test"]

    types: [requested]



jobs:

  all_triggers:

    runs-on: ubuntu-latest



    steps:

    - uses: actions/checkout@v2

    - name: Post CDash Status

      run: scripts/ci/scripts/post-cdash-status.sh ${{ github.event.repository.full_name }} ${{ github.event.workflow_run.head_sha }} ${{ secrets.GITHUB_TOKEN }}

thirdparty/dill/dill/.gitignore

0 → 100644
+98 −0
Original line number Diff line number Diff line 


# /

/*.la

/*.lo

/.last_good_build

/.libs

/Makefile

/autom4te.cache

/config.cache

/config.h

/config.log

/config.status

/dill.c

/dill.h

/dill.vcproj.*

/dill_arm5.c

/dill_ia64.c

/dill_icode.h

/dill_sparc.c

/dill_powerpc.c

/dill_vcode.h

/dill_virtual.c

/dill_x86.c

/dill_x86_64.c

/libtool

/msvc.txt

/stamp-h*

/vc*.pch

/vm_include.c

/CMakeCache.txt

/CMakeFiles

/CTestTestfile.cmake

/Testing

/cmake_install.cmake

/*.dylib

/tests/CMakeCache.txt

/tests/CMakeTestTestfile.cmake

/tests/Testing

/tests/cmake_install.cmake

/vtests/CMakeCache.txt

/vtests/CMakeTestTestfile.cmake

/vtests/Testing

/vtests/cmake_install.cmake



# /tests/

/tests/*.stamp

/tests/*~

/tests/.libs

/tests/.pure

/tests/.~*

/tests/Makefile

/tests/call-test

/tests/call-test.c

/tests/core

/tests/core.*

/tests/cplus

/tests/ctest

/tests/jal-test

/tests/pkg_test

/tests/reg-test

/tests/regress

/tests/regress.c

/tests/stest

/tests/t1

/tests/tmp.out

/tests/CMakeCache.txt

/tests/CMakeFiles

/tests/CTestTestfile.cmake

/tests/Testing

/tests/cmake_install.cmake



# /vtests/

/vtests/.libs

/vtests/.pure

/vtests/Makefile

/vtests/basic_call

/vtests/basic_call.stamp

/vtests/branch

/vtests/general

/vtests/general.c

/vtests/opt

/vtests/pkg_test

/vtests/t1

/vtests/multi_test

/vtests/*.orig

/vtests/prefix_test

/vtests/cmake_install.cmake

/vtests/CMakeFiles

/vtests/CTestTestfile.cmake

/vtests/Testing

/vtests/vbasic_call

/vtests/vbranch

/vtests/vgeneral

/vtests/vmulti_test

/vtests/vopt

/vtests/vpkg_test

/vtests/vt1

/vtests/vprefix_test

thirdparty/dill/dill/CMakeLists.txt

0 → 100644
+531 −0
Original line number Diff line number Diff line 
cmake_minimum_required(VERSION 3.0)



# The directory label is used for CDash to treat DILL as a subproject of GTKorvo

set(CMAKE_DIRECTORY_LABELS DILL)



project(DILL VERSION 2.4.1 LANGUAGES C CXX)



# Some boilerplate to setup nice output directories

include(GNUInstallDirs)

set(CMAKE_INSTALL_CMAKEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/dill

  CACHE STRING "Installation CMake subdirectory")

mark_as_advanced(CMAKE_INSTALL_CMAKEDIR)



list(INSERT CMAKE_PREFIX_PATH 0 ${CMAKE_INSTALL_PREFIX})

list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_CURRENT_SOURCE_DIR}/cmake)

if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)

  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY

    ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})

endif()

if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)

  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY

    ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})

endif()

if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)

  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY

    ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})

endif()



if(NOT DEFINED DILL_RUNTIME_COMPONENT)

  set(DILL_RUNTIME_COMPONENT bin)

endif()

if(NOT DEFINED DILL_LIBRARY_COMPONENT)

  set(DILL_LIBRARY_COMPONENT shlib)

endif()

if(NOT DEFINED DILL_ARCHIVE_COMPONENT)

  set(DILL_ARCHIVE_COMPONENT lib)

endif()

if(NOT DEFINED DILL_HEADER_COMPONENT)

  set(DILL_HEADER_COMPONENT dev)

endif()



if(WIN32)

  # Automagic to do the DLL / LIB song and dance

  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)



  # Silence MSVC warnings

  if(CMAKE_C_COMPILER_ID MATCHES "MSVC" OR

     CMAKE_C_SIMULATE_ID MATCHES "MSVC")

    add_definitions(

      -D_CRT_SECURE_NO_DEPRECATE

      -D_CRT_SECURE_NO_WARNINGS

      -D_SCL_SECURE_NO_DEPRECATE

      -D_WINSOCK_DEPRECATED_NO_WARNINGS

      -D_CRT_NONSTDC_NO_DEPRECATE)

    set (MSVC_PERL_FLAGS "-msvc-long")

  endif()

endif()



# -O3 is known to crash some flavors of clang 14.

if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND

   CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 14.0.0)

  foreach(_var_suffix IN ITEMS "" _DEBUG _RELEASE _RELWITHDEBINFO _MINSIZEREL)

    string(REGEX REPLACE "-O(2|3)" "-O" CMAKE_C_FLAGS${_var_suffix}

      "${CMAKE_C_FLAGS${_var_suffix}}")

  endforeach()

endif()



# Setup shared library defaults.  If explicitly specified somehow, then default 

# to that.  Otherwise base the default on whether or not shared libs are even

# supported.

include(CMakeDependentOption)

get_property(SHARED_LIBS_SUPPORTED GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)

cmake_dependent_option(BUILD_SHARED_LIBS

  "Build shared libraries (so/dylib/dll)." ${SHARED_LIBS_SUPPORTED}

  "SHARED_LIBS_SUPPORTED" OFF

)

mark_as_advanced(BUILD_SHARED_LIBS)



# Default to a RelWithDebInfo build if not specified

if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)

  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY VALUE RelWithDebInfo)

endif()



set(SRC_list

  dill_util.c

  dill_pkg.c

  dill_cplus.c

  dill_virtual.c

  virtual.c

  dill.c

  vm.c

)



set(TARGET_DEP_INC)

set(TARGET_DEP_LIBS)

set(PKG_DEP_PKG)

set(PKG_DEP_LIBS)



include(CheckTypeSize)

check_type_size("void*" CMAKE_SIZEOF_VOID_P)

check_type_size("long" SIZEOF_LONG)

set(NATIVE_CG TRUE)

unset(NATIVE_ARCH)

if(CMAKE_SYSTEM_PROCESSOR MATCHES "i.86|x86_64|AMD64")

  if(CMAKE_SIZEOF_VOID_P EQUAL 8)

    set(NATIVE_ARCH x86_64)

    set(HOST_X86_64 1)

    set(TEST_PERL_FLAGS "-max_arg=4")

    set(ARCH_FILE x86_64)

  else()

    set(NATIVE_ARCH x86)

    set(HOST_X86 1)

    set(TEST_PERL_FLAGS -no_float -max_arg=2)

    set(ARCH_FILE x86)

  endif()

  if(NOT (CMAKE_SIZEOF_VOID_P EQUAL SIZEOF_LONG))

    set(BASE_OPS_ARG "-msvc_long")

  endif()

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm.5.*")

  set(NATIVE_ARCH arm5)

  set(HOST_ARM5 1)

  set(TEST_PERL_FLAGS -max_arg=4)

  set(ARCH_FILE arm5)

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm.7.")

  set(NATIVE_ARCH arm6)

  set(HOST_ARM7 1)

  set(TEST_PERL_FLAGS -max_arg=4)

  set(ARCH_FILE arm6)

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm.*")

  set(NATIVE_ARCH arm6)

  set(HOST_ARM6 1)

  set(TEST_PERL_FLAGS -max_arg=4)

  set(ARCH_FILE arm6)

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")

  set(NATIVE_ARCH arm8)

  set(HOST_ARM8 1)

  set(ARCH_FILE arm8)

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")

  set(NATIVE_ARCH ppc64le)

  set(HOST_PPC64LE 1)

  set(ARCH_FILE ppc64le)

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "s64fx")

  set(NATIVE_ARCH sparcv9)

  set(HOST_SPARCV9 1)

  set(ARCH_FILE sparc)

else()

  message(STATUS "NO CG for Processor \"${CMAKE_SYSTEM_PROCESSOR}\"")

  set(NATIVE_CG FALSE)

  set(NATIVE_ARCH UNSUPPORTED)

endif()



if(CMAKE_SYSTEM_NAME MATCHES "Darwin|Linux")

  set(USE_MMAP_CODE_SEG 1)

elseif(CMAKE_SYSTEM_NAME MATCHES "Windows")

  set(USE_VIRTUAL_PROTECT 1)

endif()



include(TestBigEndian)

test_big_endian(WORDS_BIGENDIAN)



set(HARDFP_AVAILABLE 0)

# Determine float ABI of ARM Linux

if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" AND

   CMAKE_SYSTEM_NAME STREQUAL "Linux")

  find_program(READELF readelf)

  if(READELF)

    find_library(MATH_LIBRARY m)

    execute_process(

      COMMAND ${READELF} -A ${MATH_LIBRARY}

      OUTPUT_VARIABLE ELF_ARCH

      ERROR_QUIET

    )

    if(ELF_ARCH MATCHES "Tag_ABI_VFP_args: VFP registers")

      set(HARDFP_AVAILABLE 1)

    endif()

  else()

    message(WARNING "readelf not found; float ABI detection disabled")

  endif()

endif()

set(ARM_HARD_FLOAT ${HARDFP_AVAILABLE})



option(DILL_IGNORE_NATIVE  "Build to do emulation, regardless of architecture"

  OFF)

if(DILL_IGNORE_NATIVE)

  set(NATIVE_CG FALSE)

  set(NATIVE_ARCH UNSUPPORTED)

endif()

set(LIBFFI_INTERNAL OFF)

find_package(LibFFI)

if(LIBFFI_FOUND)

  message(STATUS "Enabling emulation")

  set(EMULATION_POSSIBLE TRUE)

elseif(DILL_IGNORE_NATIVE OR (NATIVE_ARCH STREQUAL "UNSUPPORTED"))

  find_program (AUTOCONF autoconf)

  find_program (AUTOMAKE automake)

  if ((AUTOCONF STREQUAL "AUTOCONF-NOTFOUND") OR (AUTOMAKE STREQUAL "AUTOMAKE-NOTFOUND"))

    if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)

      # I am top-level project.

      message(FATAL_ERROR "DILL_IGNORE_NATIVE set or native architecture unsupported, but autoconf or automake not found, so unable to build libffi")

    else()

      # I am called from other project with add_subdirectory().

      message(STATUS "DILL_IGNORE_NATIVE set or native architecture unsupported, but autoconf or automake not found, so unable to build libffi")

      return()

    endif()

  endif()

  set(LIBFFI_INTERNAL ON)

  message(STATUS "Using private copy of libffi")

  include(ExternalProject)

  if(BUILD_SHARED_LIBS)

    set(libffi_shared_args --enable-shared --disable-static)

  else()

    set(libffi_shared_args --disable-shared --enable-static)

  endif()

  ExternalProject_Add(libffi

    PREFIX ${CMAKE_BINARY_DIR}/libffi

    INSTALL_DIR ${CMAKE_BINARY_DIR}/libffi/install

    URL https://github.com/libffi/libffi/archive/master.zip

    BUILD_IN_SOURCE TRUE

    CONFIGURE_COMMAND

      ./autogen.sh &&

      ./configure

        ${libffi_shared_args}

        --prefix=<INSTALL_DIR>

        --includedir=<INSTALL_DIR>/include

        --libdir=<INSTALL_DIR>/lib

        --disable-multi-os-directory

        --disable-docs

  )

  ExternalProject_Get_property(libffi INSTALL_DIR)

  set(LIBFFI_PREFIX "${INSTALL_DIR}")

  install(DIRECTORY ${LIBFFI_PREFIX}/lib/ DESTINATION ${CMAKE_INSTALL_LIBDIR})



  # This directory has to exist at configure time or we get a buggy CMake error

  file(MAKE_DIRECTORY "${LIBFFI_PREFIX}/include")



  set(LIBFFI_INCLUDE_DIRS ${LIBFFI_PREFIX}/include)

  if(BUILD_SHARED_LIBS)

    set(LIBFFI_LIBRARIES ${LIBFFI_PREFIX}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}ffi${CMAKE_SHARED_LIBRARY_SUFFIX})

  else()

    set(LIBFFI_LIBRARIES ${LIBFFI_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}ffi${CMAKE_STATIC_LIBRARY_SUFFIX})

  endif()

  set(PC_LIBFFI_FOUND IGNORE)

  find_package(LibFFI)

  add_dependencies(libffi::libffi libffi)



  if(NOT BUILD_SHARED_LIBS)

    install(FILES ${PROJECT_SOURCE_DIR}/cmake/FindLibFFI.cmake

      DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT ${DILL_HEADER_COMPONENT})

  endif()



  message(STATUS "Enabling emulation")

  set(EMULATION_POSSIBLE TRUE)

else()

  message(STATUS "Disabling emulation")

  set(EMULATION_POSSIBLE FALSE)

endif()



find_package(Perl REQUIRED)



option(DILL_ENABLE_DISASSEMBLY

  "enable binutils-based disassembly (default is OFF)" OFF)



set(ARCHITECTURES sparc ppc64le virtual x86 x86_64 ia64 arm5 arm6 arm8)

foreach(_arch ${ARCHITECTURES})

  add_custom_command(

    OUTPUT dill_${_arch}.c

    COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${_arch}.ops

    DEPENDS ${_arch}.ops

  ) 

  list(APPEND arch_files dill_${_arch}.c ${_arch}.c)

  if(NOT _arch STREQUAL "virtual")

    list(APPEND arch_files ${_arch}_rt.c)

  endif()

endforeach()



add_custom_command(

  OUTPUT dill.h dill.c

  COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/base.ops ${BASE_OPS_ARG}

  DEPENDS base.ops

) 



option(DILL_MULTI_TARGET  "Build all available target architectures" OFF)



if(DILL_MULTI_TARGET)

  message(STATUS "arch files is ${arch_files}")

  list(APPEND SRC_list ${arch_files})

elseif(NOT ${NATIVE_ARCH} STREQUAL "UNSUPPORTED")

  list(APPEND SRC_list dill_${ARCH_FILE}.c ${ARCH_FILE}.c ${ARCH_FILE}_rt.c)

endif()



# The MULTI_TARGET variable is only used to generate the preprocessor symbol

# in config.h.  Use the DIL_MULTI_CONFIG option variable for all associated

# logic in the build.

set(MULTI_TARGET ${DILL_MULTI_TARGET})



if(DILL_MULTI_TARGET OR NATIVE_CG OR EMULATION_POSSIBLE)

  if(EMULATION_POSSIBLE)

    list(APPEND TARGET_DEP_TGT libffi::libffi)

    list(APPEND PKG_DEP_PKG libffi)

  endif()

  if(NOT DILL_MULTI_TARGET AND NOT NATIVE_CG)

    message(STATUS

      "Configure has detected no native dynamic code generation support 

   for this architecture (\"${NATIVE_ARCH}\").  However, the libffi

   library was found, so a library configured for emulation will be built."

    )

    set(EMULATION_ONLY TRUE)

    set(BUILD_EMULATOR TRUE)

  endif()

else()

  if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)

    # I am top-level project.

    message(FATAL_ERROR

	"Configure has detected no native dynamic code generation support 

	 for this architecture (\"${NATIVE_ARCH}\"), -DDILL_MULTI_TARGET=ON 

	 was not specified, and no emulation is possible (libffi library 

	 not found)  NO LIBRARY WILL BE BUILT" )

  else()

    message(STATUS

	"No native dynamic code generation support for this architecture 

	(\"${CMAKE_SYSTEM_PROCESSOR}\"), -DDILL_MULTI_TARGET=ON was not specified, and no emulation 

	is possible (libffi library not found) NO DILL LIBRARY WILL BE BUILT, but this is not a failure")

    return()

  endif()

endif()



include(CheckIncludeFiles)

check_include_files(unistd.h HAVE_UNISTD_H)

check_include_files(stdarg.h STDC_HEADERS)

check_include_files(malloc.h HAVE_MALLOC_H)

check_include_files(memory.h HAVE_MEMORY_H)

check_include_files(sys/mman.h HAVE_SYS_MMAN_H)

include(CheckSymbolExists)

check_symbol_exists(__clear_cache "" CLEAR_CACHE_DEFINED)

message(STATUS "Clear cache defined is ${CLEAR_CACHE_DEFINED}")



set(NO_DISASSEMBLER TRUE)

if(DILL_ENABLE_DISASSEMBLY)

  find_package(BinUtils REQUIRED)

  #list(APPEND TARGET_DEP_TGT binutils::opcodes)

  list(APPEND TARGET_DEP_TGT binutils::bfd)

  list(APPEND PKG_DEP_LIBS ${BinUtils_LIBRARIES})



  set(HAVE_DIS_ASM_H TRUE)

  set(NO_DISASSEMBLER FALSE)



  include(CheckCSourceCompiles)

  include(CMakePushCheckState)

  cmake_push_check_state(RESET)



  set(CMAKE_REQUIRED_INCLUDES ${BinUtils_INCLUDE_DIRS})

  set(CMAKE_REQUIRED_LIBRARIES ${BinUtils_LIBRARIES})

  check_c_source_compiles([=[

#include "dis-asm.h"

void main()

{

  struct disassemble_info info;

  INIT_DISASSEMBLE_INFO(info, stdout, fprintf);

}

]=]

    INIT_DISASSEMBLE_INFO_THREE_ARG

  )



  include(CheckFunctionExists)

  check_function_exists(print_insn_sparc          HAVE_PRINT_INSN_SPARC)

  check_function_exists(print_insn_big_powerpc    HAVE_PRINT_INSN_BIG_POWERPC)

  check_function_exists(print_insn_little_powerpc HAVE_PRINT_INSN_LITTLE_POWERPC)

  check_function_exists(print_insn_ia64           HAVE_PRINT_INSN_IA64)

  check_function_exists(print_insn_i386           HAVE_PRINT_INSN_I386)

  check_function_exists(print_insn_arm            HAVE_PRINT_INSN_ARM)

  check_function_exists(print_insn_little_arm     HAVE_PRINT_INSN_LITTLE_ARM)



  cmake_pop_check_state()

endif()



set(DILL_LIBRARY_PREFIX "" CACHE STRING

  "Prefix to prepend to the output library name")

mark_as_advanced(DILL_LIBRARY_PREFIX)



add_library(dill ${SRC_list})

set_target_properties(dill PROPERTIES

  OUTPUT_NAME ${DILL_LIBRARY_PREFIX}dill

  VERSION ${DILL_VERSION}

  SOVERSION ${DILL_VERSION_MAJOR})

add_library(dill::dill ALIAS dill)



target_include_directories(dill

  PUBLIC

    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>

    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>

    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>

  PRIVATE

    ${TARGET_DEP_INC}

)

target_link_libraries(dill PRIVATE ${TARGET_DEP_TGT} ${TARGET_DEP_LIBS})



# Setup pkgconfig

option(DILL_INSTALL_PKGCONFIG "Install Dill pkgconfig files" ON)

mark_as_advanced(DILL_INSTALL_PKGCONFIG)

if(DILL_INSTALL_PKGCONFIG)

  set(_pkg_config_private_libs)

  foreach(L ${PKG_DEP_LIBS})

    if(L MATCHES "(.*)/?lib(.*)\\.")

      if(CMAKE_MATCH_1)

        list(APPEND _pkg_config_private_libs "-L${CMAKE_MATCH_1}")

      endif()

      list(APPEND _pkg_config_private_libs "-l${CMAKE_MATCH_2}")

    elseif(L MATCHES "^-")

      list(APPEND _pkg_config_private_libs "${L}")

    else()

      list(APPEND _pkg_config_private_libs "-l${L}")

    endif()

  endforeach()

  if(_pkg_config_private_libs)

    list(REMOVE_DUPLICATES _pkg_config_private_libs)

  endif()

  string(REPLACE ";" " " _pkg_config_private_libs "${_pkg_config_private_libs}")

  string(REPLACE ";" " " _pkg_config_req_pkg "${PKG_DEP_PKG}")

  configure_file(

    ${CMAKE_CURRENT_SOURCE_DIR}/dill.pc.in

    ${CMAKE_CURRENT_BINARY_DIR}/dill.pc

    @ONLY

  )

  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/dill.pc

    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig" COMPONENT ${DILL_HEADER_COMPONENT})

  configure_file(

    ${CMAKE_CURRENT_SOURCE_DIR}/dill-config.in

    ${CMAKE_CURRENT_BINARY_DIR}/dill-config

    @ONLY

  )

  install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/dill-config

    DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT ${DILL_HEADER_COMPONENT})

endif()



option(DILL_INSTALL_HEADERS "Install Dill header files" ON)

mark_as_advanced(DILL_INSTALL_HEADERS)

if(DILL_INSTALL_HEADERS)

  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/dill.h"

    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" COMPONENT ${DILL_HEADER_COMPONENT})

endif()



set(namelink_component_args)

if(NOT CMAKE_VERSION VERSION_LESS 3.12)

  set(namelink_component_args NAMELINK_COMPONENT ${DILL_HEADER_COMPONENT})

endif()

install(TARGETS dill

  # IMPORTANT: Add the dill library to the "export-set"

  EXPORT dill-targets

  RUNTIME       DESTINATION "${CMAKE_INSTALL_BINDIR}"          COMPONENT ${DILL_RUNTIME_COMPONENT}

  LIBRARY       DESTINATION "${CMAKE_INSTALL_LIBDIR}"          COMPONENT ${DILL_LIBRARY_COMPONENT} ${namelink_component_args}

  ARCHIVE       DESTINATION "${CMAKE_INSTALL_LIBDIR}"          COMPONENT ${DILL_ARCHIVE_COMPONENT}

  PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/dill" COMPONENT ${DILL_HEADER_COMPONENT})



if(${CMAKE_C_COMPILER_ID} MATCHES "Intel") 

    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -shared-intel")

endif()



configure_file(

  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake

  ${CMAKE_CURRENT_BINARY_DIR}/config.h)



# Add all targets to the build-tree export set

export(TARGETS dill NAMESPACE dill::

  FILE "${PROJECT_BINARY_DIR}/dill-targets.cmake")

 

configure_file(dill-config-common.cmake.in

  "${PROJECT_BINARY_DIR}/dill-config-common.cmake" @ONLY)



configure_file(dill-config-version.cmake.in

  "${PROJECT_BINARY_DIR}/dill-config-version.cmake" @ONLY)

 

configure_file(dill-config.cmake.in

  "${PROJECT_BINARY_DIR}/dill-config.cmake" @ONLY)



configure_file(dill-config-install.cmake.in

  "${PROJECT_BINARY_DIR}/dill-config-install.cmake" @ONLY)



# Install the dill-config.cmake and dill-config-version.cmake

install(FILES

  "${PROJECT_BINARY_DIR}/dill-config-common.cmake"

  "${PROJECT_BINARY_DIR}/dill-config-version.cmake"

  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT ${DILL_HEADER_COMPONENT})



install(

  FILES "${PROJECT_BINARY_DIR}/dill-config-install.cmake"

  RENAME dill-config.cmake

  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT ${DILL_HEADER_COMPONENT})

 

# Install the export set for use with the install-tree

install(EXPORT dill-targets NAMESPACE dill::

  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT ${DILL_HEADER_COMPONENT})



# Install extra find module dependencies

install(DIRECTORY ${PROJECT_SOURCE_DIR}/cmake/

  DESTINATION ${CMAKE_INSTALL_CMAKEDIR} COMPONENT ${DILL_HEADER_COMPONENT}

  FILES_MATCHING PATTERN "Find*.cmake" PATTERN "CMake*.cmake"

)



# display status message for important variables

include(CTest)

mark_as_advanced(BUILD_TESTING)



if(BUILD_TESTING)

  enable_testing()

  set(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")

  mark_as_advanced(BUILDNAME)

  if(NATIVE_CG)

    add_subdirectory(tests)

  endif()

  add_subdirectory(vtests)

endif()



configure_file(

  ${PROJECT_SOURCE_DIR}/CTestCustom.cmake.in

  ${PROJECT_BINARY_DIR}/CTestCustom.cmake

  @ONLY

)



option(DILL_QUIET "Suppress summary output" OFF)

if(NOT DILL_QUIET)

  message(STATUS)

  message(STATUS "-----------------------------------------------------------------------------")

  message(STATUS "CMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}" )

  message(STATUS "CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}" )

  message(STATUS "DILL_ENABLE_DISASSEMBLY = ${DILL_ENABLE_DISASSEMBLY}" )

  message(STATUS "DILL_MULTI_TARGET = ${DILL_MULTI_TARGET}" )

  message(STATUS "BUILD_SHARED_LIBS = ${BUILD_SHARED_LIBS}" )

  message(STATUS "BUILD_TESTING = ${BUILD_TESTING}" )

  message(STATUS "Change a value with: cmake -D<Variable>=<Value>" )

  message(STATUS "-----------------------------------------------------------------------------")

endif()

thirdparty/dill/dill/CTestConfig.cmake

0 → 100644
+9 −0
Original line number Diff line number Diff line 
set(CTEST_PROJECT_NAME "GTKorvo")

set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC")



set(CTEST_DROP_METHOD "http")

set(CTEST_DROP_SITE "open.cdash.org")

set(CTEST_DROP_LOCATION "/submit.php?project=GTKorvo")

set(CTEST_DROP_SITE_CDASH TRUE)



set(CTEST_LABELS_FOR_SUBPROJECTS DILL)