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

Merge branch 'upstream-dill' into fix-export-configs 

* upstream-dill:
  dill 2018-12-31 (75e27efb)
parents dd2b7acc 7face8c1

thirdparty/dill/dill/CMakeLists.txt

+268 −270
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ mark_as_advanced(CMAKE_INSTALL_LIBDIR) 
mark_as_advanced(CMAKE_INSTALL_INCLUDEDIR)

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
@@ -28,42 +29,10 @@ if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) 
    ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})

endif()



include(CheckCSourceCompiles)

include(CheckFunctionExists)

include(CheckLibraryExists)

include(CheckIncludeFiles)

include(CheckTypeSize)

include(Compile)

include(TestBigEndian)





# use, i.e. don't skip the full RPATH for the build tree

SET(CMAKE_SKIP_BUILD_RPATH  FALSE)



# when building, don't use the install RPATH already

# (but later on when installing)

SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) 



SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")



# add the automatically determined parts of the RPATH

# which point to directories outside the build tree to the install RPATH

SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)



# the RPATH to be used when installing, but only if it's not a system directory

LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)

IF("${isSystemDir}" STREQUAL "-1")

   SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")

ENDIF("${isSystemDir}" STREQUAL "-1")



set (CMAKE_MACOSX_RPATH 1)



include(CMakeDependentOption)

include(ExternalProject)



# 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}
@@ -71,137 +40,165 @@ cmake_dependent_option(BUILD_SHARED_LIBS 
)

mark_as_advanced(BUILD_SHARED_LIBS)



# Setup PIC defaults.  If explicitly specified somehow, then default 

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

# supported.

if(DEFINED DILL_ENABLE_PIC)

  set(DILL_ENABLE_PIC_DEFAULT ${DILL_ENABLE_PIC})

elseif(DEFINED CMAKE_POSITION_INDEPENDENT_CODE)

  set(DILL_ENABLE_PIC_DEFAULT ${CMAKE_POSITION_INDEPENDENT_CODE})

else()

  set(DILL_ENABLE_PIC_DEFAULT ${SHARED_LIBS_SUPPORTED})

endif()

cmake_dependent_option(DILL_ENABLE_PIC

  "Build with Position Independent Code" ${DILL_ENABLE_PIC_DEFAULT}

  "SHARED_LIBS_SUPPORTED" OFF

)

mark_as_advanced(DILL_ENABLE_PIC)

set(CMAKE_POSITION_INDEPENDENT_CODE ${DILL_ENABLE_PIC})

mark_as_advanced(CMAKE_POSITION_INDEPENDENT_CODE)



# 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 RelWithDebugInfo)

endif()



set(SRC_list

  dill_util.c

  dill_pkg.c

  dill_cplus.c

  dill_virtual.c

  virtual.c

  dill.c

  vm.c

)



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)



CHECK_TYPE_SIZE("void*" CMAKE_SIZEOF_VOID_P)

CHECK_TYPE_SIZE("long" SIZEOF_LONG)

set (NATIVE_CG true)

if (("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "i.86") OR

	("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "x86_64") OR

	("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "AMD64"))

    if (CMAKE_SIZEOF_VOID_P MATCHES "8")

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 (CMAKE_SIZEOF_VOID_P MATCHES "8")

  else()

    set(NATIVE_ARCH x86)

    set(HOST_X86 1)

    set(TEST_PERL_FLAGS -no_float -max_arg=2)

    set(ARCH_FILE x86)

    endif (CMAKE_SIZEOF_VOID_P MATCHES "8")

elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "arm.*")

    if ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "arm.5.*")

  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.6.")

	set (NATIVE_ARCH arm6)

	set (HOST_ARM6 1)

	set (TEST_PERL_FLAGS -max_arg=4)

	set (ARCH_FILE arm6)

    elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "arm.7.")

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)

    else ()

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)

    endif()

elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "aarch64")

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")

  set(NATIVE_ARCH arm8)

  set(HOST_ARM8 1)

  set(ARCH_FILE arm8)

elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "ppc64le")

elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")

  set(NATIVE_ARCH ppc64le)

  set(HOST_PPC64LE 1)

  set(ARCH_FILE ppc64le)

elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "s64fx")

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)

  set(NATIVE_CG FALSE)

endif()



IF ((${CMAKE_SYSTEM_NAME} MATCHES "Darwin") OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux"))

if(CMAKE_SYSTEM_NAME MATCHES "Darwin|Linux")

  set(USE_MMAP_CODE_SEG 1)

ENDIF()

endif()



include(TestBigEndian)

test_big_endian(WORDS_BIGENDIAN)



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")

if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" AND

   CMAKE_SYSTEM_NAME STREQUAL "Linux")

  find_program(READELF readelf)

    if (READELF MATCHES "NOTFOUND")

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

    else (READELF MATCHES "NOTFOUND")

        find_library(MATH_LIBRARY m /usr/lib)

  if(READELF)

    find_library(MATH_LIBRARY m)

    execute_process(

      COMMAND ${READELF} -A ${MATH_LIBRARY}

      OUTPUT_VARIABLE ELF_ARCH

            ERROR_QUIET)

      ERROR_QUIET

    )

    if(ELF_ARCH MATCHES "Tag_ABI_VFP_args: VFP registers")

      set(HARDFP_AVAILABLE 1)

    endif()

    endif (READELF MATCHES "NOTFOUND")

endif (CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" AND CMAKE_SYSTEM_NAME STREQUAL "Linux")

  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)

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

  OFF)

if(DILL_IGNORE_NATIVE)

    set (NATIVE_CG false)

    set (NATIVE_ARCH UNSUPPORTED)

  set(NATIVE_CG FALSE)

endif()

set(LIBFFI_INTERNAL OFF)

find_package(LibFFI)

if(LIBFFI_FOUND)

  message(STATUS "Enabling emulation")

  set(EMULATION_POSSIBLE TRUE)

elseif(DILL_IGNORE_NATIVE)

  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()

find_package (LibFFI PATHS ${CMAKE_INSTALL_PREFIX} QUIET)

IF (LIBFFI_FOUND) 

  set (EMULATION_POSSIBLE true)

ELSEIF (DILL_IGNORE_NATIVE)

  set(FFI_PREFIX_DIR ${CMAKE_BINARY_DIR}/libffi)

  set(FFI_SRC_DIR ${FFI_PREFIX_DIR}/src/LibFFI)

  set(FFI_INSTALL_DIR ${FFI_PREFIX_DIR}/install)

  ExternalProject_Add(LibFFI

    PREFIX ${FFI_PREFIX_DIR}

    GIT_REPOSITORY https://github.com/libffi/libffi.git

    CONFIGURE_COMMAND cd ${FFI_SRC_DIR} && ./autogen.sh COMMAND ${FFI_SRC_DIR}/configure --prefix=${FFI_PREFIX_DIR}

  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

  )

  set (EMULATION_POSSIBLE true)

  ExternalProject_Get_property(LibFFI install_dir)

  set (LIBFFI_INCLUDE_DIR ${install_dir}/include)

  link_directories(${install_dir}/lib)

  set (LIBFFI_LIBRARY -lffi)

ENDIF()

  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 dev)

  endif()



  message(STATUS "Enabling emulation")

  set(EMULATION_POSSIBLE TRUE)

else()

  message(STATUS "Disabling emulation")

  set(EMULATION_POSSIBLE FALSE)

endif()



option(DILL_ENABLE_DISASSEMBLY

  "enable binutils-based disassembly (default is OFF)" OFF)
@@ -209,16 +206,18 @@ option(DILL_ENABLE_DISASSEMBLY 
set(ARCHITECTURES sparc ppc64le virtual x86 x86_64 ia64 arm5 arm6 arm8)

foreach(_arch ${ARCHITECTURES})

  add_custom_command(

    OUTPUT "dill_${_arch}.c"

    OUTPUT dill_${_arch}.c

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

    DEPENDS ${_arch}.ops

  ) 

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

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

  if(NOT _arch STREQUAL "virtual")

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

  endif()

endforeach()

list(REMOVE_ITEM arch_files virtual_rt.c)



add_custom_command(

  OUTPUT "dill.h" "dill.c"

  OUTPUT dill.h dill.c

  COMMAND perl ${CMAKE_CURRENT_SOURCE_DIR}/base.ops

  DEPENDS base.ops

)
@@ -227,9 +226,9 @@ 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)

  list(APPEND SRC_list ${arch_files})

elseif(NATIVE_ARCH) 

  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
@@ -239,122 +238,103 @@ set(MULTI_TARGET ${DILL_MULTI_TARGET}) 


if(DILL_MULTI_TARGET OR NATIVE_CG OR EMULATION_POSSIBLE)

  if(EMULATION_POSSIBLE)

	set (EMU_LIB ${LIBFFI_LIBRARY})

	INCLUDE_DIRECTORIES(${LIBFFI_INCLUDE_DIR})

    endif(EMULATION_POSSIBLE)

    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 library configure for emulation will be built.")

	set (EMULATION_ONLY true)

	set (BUILD_EMULATOR true)

	LIST(APPEND TARGET_DEP_LIBS ${EMU_LIB})

    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()

    message ( FATAL_ERROR "Configure has detected no native dynamic code generation support 

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

  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")

   NO LIBRARY WILL BE BUILT"

  )

endif()



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)

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)



set(NO_DISASSEMBLER TRUE)

if(DILL_ENABLE_DISASSEMBLY)

    if (BINUTILS_DIR) 

      set(BINUTILS_LIB_SEARCH ${BINUTILS_DIR}/lib ${BINUTILS_DIR}/lib64)

      set(BINUTILS_INC_SEARCH ${BINUTILS_DIR}/include)

    endif()

    find_library(LIBOPCODES NAMES opcodes HINTS ${BINUTILS_LIBRARIES} PATHS /usr/lib

      /usr/lib64

      /usr/local/lib

      /usr/local/lib64

      /opt/local/lib

      /opt/local/lib64

      ${BINUTILS_LIB_SEARCH}

      ENV LIBRARY_PATH

      ENV LD_LIBRARY_PATH)

    find_library(LIBBFD NAMES bfd HINTS ${BINUTILS_LIBRARIES} PATHS /usr/lib

      /usr/lib64

      /usr/local/lib

      /usr/local/lib64

      /opt/local/lib

      /opt/local/lib64

      ${BINUTILS_LIB_SEARCH}

      ENV LIBRARY_PATH

      ENV LD_LIBRARY_PATH)

    find_path (BINUTILS_INCLUDE_DIR

      NAMES

      dis-asm.h

      PATHS

      /usr/include

      /usr/local/include

      /opt/local/include

      /opt/include

      ${BINUTILS_INC_SEARCH}

      ENV 

      ENV CPATH)

    if (("${LIBOPCODES}" STREQUAL "LIBOPCODES-NOTFOUND") OR 

	("${BINUTILS_INCLUDE_DIR}" STREQUAL "BINUTILS_INCLUDE_DIR-NOTFOUND"))

	message(FATAL_ERROR "libopcodes not found, You need to install binutils for disassembler support.")

    else()

	INCLUDE_DIRECTORIES(${BINUTILS_INCLUDE_DIR})

	set(HAVE_DIS_ASM_H true)

	LINK_DIRECTORIES(${BINUTILS_LIB_DIR})

	LIST(APPEND TARGET_DEP_LIBS opcodes bfd )

	set(DIS_LIBS ${TARGET_DEP_LIBS})

  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)

    endif()

    set (BINUTILS_LIBRARIES ${LIBOPCODES} ${LIBBFD})

    if(NOT DEFINED INIT_DISASSEMBLE_INFO_THREE_ARG)

	#if not in Cache

    	FILE (WRITE check_init_disassemble_args.c "#include \"dis-asm.h\"

extern int main() {struct disassemble_info info;INIT_DISASSEMBLE_INFO(info, stdout, fprintf);}" )

    	TRY_COMPILE (INIT_DISASSEMBLE_INFO_THREE_ARGUMENTS ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/check_init_disassemble_args.c CMAKE_FLAGS "-DCMAKE_C_LINK_EXECUTABLE=echo" COMPILE_DEFINITIONS -I${BINUTILS_INCLUDE_DIR} OUTPUT_VARIABLE LOG2)

    	FILE (REMOVE check_init_disassemble_args.c)

	message (STATUS "Checking to see that the INIT_DISASSEMBLE_INFO macro requires three arguments :${INIT_DISASSEMBLE_INFO_THREE_ARGUMENTS}")

	set (INIT_DISASSEMBLE_INFO_THREE_ARG ${INIT_DISASSEMBLE_INFO_THREE_ARGUMENTS} CACHE BOOL "Does the INIT_DISASSEMBLE_INFO macro require three arguments")

    endif()

    SET (CMAKE_REQUIRED_LIBRARIES ${LIBBFD})

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_sparc "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_SPARC)

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_big_powerpc "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_BIG_POWERPC)

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_little_powerpc "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_LITTLE_POWERPC)

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_ia64 "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_IA64)

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_i386 "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_I386)

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_arm "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_ARM)

    CHECK_LIBRARY_EXISTS(${LIBOPCODES} print_insn_little_arm "${BINUTILS_LIB_DIR}" HAVE_PRINT_INSN_LITTLE_ARM)



  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()



  if(NOT BUILD_SHARED_LIBS)

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

      DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT dev)

  endif()

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})

if (FFI_PREFIX_DIR)

  add_dependencies (dill LibFFI)

endif()

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

target_include_directories(dill

  PUBLIC

    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>

    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>

                           $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)

target_link_libraries(dill PRIVATE ${TARGET_DEP_LIBS})

    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>

  PRIVATE

    ${TARGET_DEP_INC}

)

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



# Setup pkgconfig

set(_pkg_config_private_libs)

foreach(L ${TARGET_DEP_LIBS})

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

foreach(L ${PKG_DEP_LIBS})

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

    if(CMAKE_MATCH_1)

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

    endif()
@@ -365,7 +345,11 @@ foreach(L ${TARGET_DEP_LIBS}) 
    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
@@ -404,18 +388,29 @@ configure_file( 
export(TARGETS dill NAMESPACE dill::

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

 

configure_file(dill-config.cmake.in

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

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.cmake"

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

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

  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT dev)



install(

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

  RENAME dill-config.cmake

  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT dev)

 

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

install(EXPORT dill-targets NAMESPACE dill::

  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" COMPONENT dev)
@@ -425,11 +420,13 @@ 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)

  ADD_SUBDIRECTORY( tests )

  ADD_SUBDIRECTORY( vtests )

  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()



option(DILL_QUIET "Suppress summary output" OFF)
@@ -440,6 +437,7 @@ if(NOT DILL_QUIET) 
  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 "-----------------------------------------------------------------------------")

thirdparty/dill/dill/cmake/FindBinUtils.cmake

+38 −25
Original line number Diff line number Diff line 
#

#  BINUTILS_FOUND - system has the BinUtils library BINUTILS_INCLUDE_DIR - the BinUtils include directory BINUTILS_LIBRARIES - The libraries needed

#  to use BinUtils

#  BinUtils_FOUND - system has the BinUtils library

#  BinUtils_INCLUDE_DIRS - the BinUtils include directory

#  BinUtils_LIBRARIES - The libraries needed to use BinUtils

#

#  Targets:

#    binutils::opcodes

#    binutils::bfd

#



find_path(BinUtils_INCLUDE_DIR dis-asm.h)

find_library(BinUtils_opcodes_LIBRARY opcodes)

find_library(BinUtils_bfd_LIBRARY bfd)



IF (NOT DEFINED BINUTILS_FOUND)

    if (NOT (DEFINED CercsArch))

        execute_process(COMMAND cercs_arch OUTPUT_VARIABLE CercsArch ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

	MARK_AS_ADVANCED(CercsArch)

    endif()

    IF(EXISTS /users/c/chaos)

        FIND_LIBRARY  (BINUTILS_LIBRARIES opcodes NAMES libopcodes.so opcodes PATHS /users/c/chaos/lib /users/c/chaos/${CercsArch}/binutils/lib /users/c/chaos/${CercsArch}/lib NO_DEFAULT_PATH)

	FIND_PATH (BINUTILS_INCLUDE_DIR NAMES dis-asm.h PATHS /users/c/chaos/include /users/c/chaos/${CercsArch}/binutils/include /users/c/chaos/${CercsArch}/include NO_DEFAULT_PATH)

    ENDIF()

    if (USE_NATIVE_LIBRARIES)

	FIND_LIBRARY (BINUTILS_LIBRARIES opcodes NAMES libopcodes.so opcodes)

	FIND_PATH (BINUTILS_INCLUDE_DIR  NAMES dis-asm.h)

    endif()

    IF (DEFINED BINUTILS_LIBRARIES)

	get_filename_component ( BINUTILS_LIB_DIR ${BINUTILS_LIBRARIES} PATH)

    ENDIF()

include(FindPackageHandleStandardArgs)

find_package_handle_standard_args(BinUtils DEFAULT_MSG

     BINUTILS_LIBRARIES

     BINUTILS_INCLUDE_DIR

     BINUTILS_LIB_DIR

  BinUtils_opcodes_LIBRARY BinUtils_bfd_LIBRARY BinUtils_INCLUDE_DIR

)

if(BinUtils_FOUND)

  set(BinUtils_INCLUDE_DIRS ${BinUtils_INCLUDE_DIR})

  set(BinUtils_LIBRARIES ${BinUtils_opcodes_LIBRARY} ${BinUtils_bfd_LIBRARY})



  if(NOT TARGET binutils::bfd)

    add_library(binutils::bfd UNKNOWN IMPORTED)

    set_target_properties(binutils::bfd PROPERTIES

      IMPORTED_LOCATION              ${BinUtils_bfd_LIBRARY}

      INTERFACE_INCLUDE_DIRECTORIES  ${BinUtils_INCLUDE_DIR}

    )

ENDIF()
 
  endif()



  if(NOT TARGET binutils::opcodes)

    add_library(binutils::opcodes UNKNOWN IMPORTED)

    set_target_properties(binutils::opcodes PROPERTIES

      IMPORTED_LOCATION              ${BinUtils_opcodes_LIBRARY}

      INTERFACE_INCLUDE_DIRECTORIES  ${BinUtils_INCLUDE_DIR}

      INTERFACE_LINK_LIBRARIES       binutils::bfd

    )

  endif()

endif()

thirdparty/dill/dill/cmake/FindLibFFI.cmake

+48 −12

File changed.

Preview size limit exceeded, changes collapsed.

thirdparty/dill/dill/dill-config-common.cmake.in

0 → 100644
+47 −0
Original line number Diff line number Diff line 
# - Config file for the Dill package

#

# It defines the following variables

#   DILL_INCLUDE_DIRS - include directories for Dill

#   DILL_LIBRARIES    - libraries to link against

#   DILL_HAS_NATIVE_DCG - Whether or not native code generation is available

#

# And the folloing imported targets:

#   dill::dill

#

 

include(CMakeFindDependencyMacro)



# Locate dependencies if building static

set(_dill_required_vars)

if(NOT @BUILD_SHARED_LIBS@)

  if(@EMULATION_POSSIBLE@)

    find_dependency(LibFFI)

    list(APPEND _dill_required_vars LibFFI_FOUND)

  endif()

  if(NOT @NO_DISASSEMBLER@)

    find_dependency(BinUtils)

    list(APPEND _dill_required_vars BinUtils_FOUND)

  endif()

endif()



if(_dill_required_vars)

  list(INSERT _dill_required_vars 0 REQUIRED_VARS)

endif()



include("${CMAKE_CURRENT_LIST_DIR}/dill-config-version.cmake")



include(FindPackageHandleStandardArgs)

find_package_handle_standard_args(${CMAKE_FIND_PACKAGE_NAME}

  CONFIG_MODE ${_dill_required_vars})



if(NOT TARGET dill::dill)

  include("${CMAKE_CURRENT_LIST_DIR}/dill-targets.cmake")

endif()



set(DILL_LIBRARIES dill::dill)

set(DILL_INCLUDE_DIRS

  $<TARGET_PROPERTY:dill::dill,INTERFACE_INCLUDE_DIRECTORIES>

)

set(DILL_HAS_NATIVE_DCG  @NATIVE_CG@)

set(DILL_HAS_EMULATION   @EMULATION_POSSIBLE@)

set(DILL_HAS_DISASSEMBLY @DILL_ENABLE_DISASSEMBLY@)

thirdparty/dill/dill/dill-config-install.cmake.in

0 → 100644
+15 −0

File added.

Preview size limit exceeded, changes collapsed.