Commit 7face8c1 authored by dill Upstream's avatar dill Upstream Committed by Atkins, Charles Vernon
Browse files

dill 2018-12-31 (75e27efb) 

Code extracted from:

    https://github.com/chuckatkins/dill.git

at commit 75e27efb16f1e0ce88982e0e4f5f972a00f5ce4e (misc-cmake-updates).

Upstream Shortlog
-----------------

Chuck Atkins (5):
      3db0f718 Remove static with PIC build option
      b522cc28 Use consistent formatting for CMake code
      a3f462dd Remove RPATH trickery as most of that should work by default
      e192941a Simplifying various cmake logic
      75e27efb Re-work the export of dependency information (i.e. ffi)
parent 34596a21

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

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

cmake/FindLibFFI.cmake

+48 −12

File changed.

Preview size limit exceeded, changes collapsed.

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

dill-config-install.cmake.in

0 → 100644
+15 −0

File added.

Preview size limit exceeded, changes collapsed.