admin/lifting-bits-sleigh
1
0
Fork 0
mirror of https://github.com/lifting-bits/sleigh synced 2026-06-21 13:56:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

CMake refactor (#105)

Browse Source 
* Major CMake refactor

* CI fixes

* Fix CMake errors

* Install graphviz on Windows

* More consistent CMake build types

* Fix compiler defines for Windows

* Fix more bugs

* Add standalone tool building support

* Fix typo

* Update README

* Install sleighLift before trying to smoketest it

* Test coverage preset

The compiler option '-fkeep-inline-functions' originally included with
the coverage build type causes errors with the message "undefined
reference to 'vtable for OpAction*'" for all OpAction subclasses.

This StackOverflow answer might help in resolving this?
https://stackoverflow.com/a/57504289

* Build documentation by default with CI presets

* Use COMPONENT for install commands

This allows for someone to specify which components they want to install
if they only want or need a subset

* Support cross compiling with host system sleigh compiler

* Various fixes found during review

* Move "_WINDOWS" define to CMakeLists.txt file

* Rename ToB 'tools' directory to 'extra-tools'

* Separate projects for sleigh tools

Library is still top-level CMakeLists.txt

More options

* CMake find_package(Git)

* Fix bad merge for patch paths

* Fix missing libconfig.h header install

* Fix issues with installation of headers

* More refactoring

* Refactor sleighexample into its own project/directory

* Refactor specfiles building into separate project/directory

* Check for termios.h header and set define if found

* Update READMEs

* Better consistency with install rules

* Build sleighLift as a standalone project with added source

* More changes to CMake subprojects

* Also add "Specs" component to sleigh installation config

* Try to be better at bootstrapping subprojects (hopefully this doesn't
  bite us, but if it does, I'm happy to remove it and say "not
  supported")

* Address some code review

* Add project sleigh_tool for tool subdirectory

Could make it easier to build just the tools

* Add help text to name the tool executable name

* Add license notice to CMake files

* Fix/Remove too specific CPack packaging configuration

* Consistent capitalization of Sleigh

Co-authored-by: Alex Cameron <asc@tetsuo.sh>
This commit is contained in:
Eric Kilmer
2022-08-21 22:41:53 -07:00
committed by GitHub
parent 72d364a90f
commit 74838a39ba
52 changed files with 1509 additions and 891 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/main.yml
+33 -24
View File
@@ -37,22 +37,16 @@ jobs:
if: runner.os == 'Linux' if: runner.os == 'Linux'
run: | run: |
sudo apt-get update sudo apt-get update
sudo apt-get install -y \ sudo apt-get install -y rpm
clang \
rpm \ # Use Homebrew for latest build tools for use in CI
brew install \
cmake \
ccache \
doxygen \ doxygen \
xdot \ xdot \
graphviz graphviz
# Minimum supported CMake version testing
curl -L "https://github.com/Kitware/CMake/releases/download/v3.18.0/cmake-3.18.0-Linux-$(uname -m).sh" -o /tmp/cmake-install.sh
mkdir -p "${HOME}/.local"
bash /tmp/cmake-install.sh --skip-license --exclude-subdir "--prefix=${HOME}/.local"
# Use Homebrew for latest build tool version for use in CI
brew install \
ccache
- name: Install macOS system dependencies - name: Install macOS system dependencies
if: runner.os == 'macOS' if: runner.os == 'macOS'
run: | run: |
@@ -65,7 +59,7 @@ jobs:
- name: Install Windows system dependencies - name: Install Windows system dependencies
if: runner.os == 'Windows' if: runner.os == 'Windows'
run: choco install ccache run: choco install ccache doxygen.install graphviz
- name: Generate cache key - name: Generate cache key
id: cache_key id: cache_key
@@ -96,6 +90,9 @@ jobs:
# This should be multiplied by the number of compilation jobs and be no # This should be multiplied by the number of compilation jobs and be no
# larger than 5G, which is the cache max size # larger than 5G, which is the cache max size
file(APPEND "$ENV{GITHUB_ENV}" "CCACHE_MAXSIZE=400M\n") file(APPEND "$ENV{GITHUB_ENV}" "CCACHE_MAXSIZE=400M\n")
# Tell CMake to use ccache
file(APPEND "$ENV{GITHUB_ENV}" "CMAKE_CXX_COMPILER_LAUNCHER=ccache\n")
file(APPEND "$ENV{GITHUB_ENV}" "CMAKE_C_COMPILER_LAUNCHER=ccache\n")
# Clear stats before every build # Clear stats before every build
execute_process(COMMAND ccache -z) execute_process(COMMAND ccache -z)
@@ -103,17 +100,10 @@ jobs:
run: cmake --version run: cmake --version
- name: Configure the project - name: Configure the project
run: cmake shell: pwsh
-S . run: cmake "--preset=ci-$("${{ matrix.os }}".split("-")[0])"
-B build
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache
-DCMAKE_C_COMPILER_LAUNCHER=ccache
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-Dsleigh_RELEASE_TYPE=${{ matrix.release }} -Dsleigh_RELEASE_TYPE=${{ matrix.release }}
-Dsleigh_ENABLE_TESTS=ON
-Dsleigh_ENABLE_EXAMPLES=ON
-Dsleigh_ENABLE_PACKAGING=ON
-Dsleigh_ENABLE_DOCUMENTATION=ON
- name: Build the project - name: Build the project
run: cmake run: cmake
@@ -122,18 +112,28 @@ jobs:
-j 2 -j 2
-v -v
- name: Build the docs
run: cmake
--build build
--config ${{ matrix.build_type }}
--target docs
-v
- name: Run the example - name: Run the example
run: cmake run: cmake
--build build --build build
-j 2 -j 2
--config ${{ matrix.build_type }} --config ${{ matrix.build_type }}
--target sleighexample_runner --target sleigh_example_runner
- name: Run the install target - name: Run the install target
run: cmake --install build run: cmake --install build
--config ${{ matrix.build_type }} --config ${{ matrix.build_type }}
--prefix install --prefix install
- name: Smoketest sleigh lift
run: ./install/bin/sleigh-lift disassemble x86-64.sla 4881ecc00f0000
- name: Test install directory - name: Test install directory
working-directory: tests/find_package working-directory: tests/find_package
run: | run: |
@@ -142,6 +142,15 @@ jobs:
cd build cd build
ctest -V -C ${{ matrix.build_type }} ctest -V -C ${{ matrix.build_type }}
- name: Test tool install directory
working-directory: extra-tools/sleigh-lift
run: |
cmake -B build -S . "-Dsleigh_DIR=${{ github.workspace }}/install/lib/cmake/sleigh" -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
cmake --build build -j 2 --config ${{ matrix.build_type }}
cmake --install build --config ${{ matrix.build_type }} --prefix install
./install/bin/sleigh-lift --version
./install/bin/sleigh-lift disassemble x86-64.sla 4881ecc00f0000
- name: Create the packages - name: Create the packages
run: cmake run: cmake
--build build --build build
@@ -224,7 +233,7 @@ jobs:
# failure state # failure state
- name: Run the tests - name: Run the tests
working-directory: build working-directory: build
run: ctest -V -C ${{ matrix.build_type }} run: ctest -VV -C ${{ matrix.build_type }}
- name: ccache stats - name: ccache stats
run: ccache -s --verbose run: ccache -s --verbose
CMakeLists.txt
+86 -690
View File
@@ -8,6 +8,8 @@
cmake_minimum_required(VERSION 3.18) cmake_minimum_required(VERSION 3.18)
include(cmake/prelude.cmake)
# Sets "library_root" variable for decompiler cpp root directory # Sets "library_root" variable for decompiler cpp root directory
# Sets "ghidra_version" for numeric version number # Sets "ghidra_version" for numeric version number
# Use "ghidrasource_SOURCE_DIR" variable for Ghidra repo root # Use "ghidrasource_SOURCE_DIR" variable for Ghidra repo root
@@ -17,29 +19,20 @@ if("${sleigh_RELEASE_TYPE}" STREQUAL "HEAD")
set(sleigh_RELEASE_IS_HEAD TRUE) set(sleigh_RELEASE_IS_HEAD TRUE)
endif() endif()
project("sleigh" project(sleigh
VERSION "${ghidra_version}" VERSION "${ghidra_version}"
DESCRIPTION "Unofficial CMake build for Ghidra Sleigh"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
LANGUAGES CXX
) )
include("cmake/options.cmake") include(cmake/project-is-top-level.cmake)
include(cmake/options.cmake)
if(sleigh_ENABLE_TESTS)
include("CTest")
endif()
if(sleigh_ENABLE_PACKAGING)
include("cmake/packaging.cmake")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
message(WARNING "sleigh: Packaging a Debug version")
endif()
endif()
#
# Move headers so we can prefix with "sleigh/"
#
set(public_include_header_list set(public_include_header_list
"${PROJECT_SOURCE_DIR}/include/libsleigh.hh"
"${PROJECT_SOURCE_DIR}/support/Support.h"
"${PROJECT_SOURCE_DIR}/support/Version.h"
"${library_root}/action.hh" "${library_root}/action.hh"
"${library_root}/address.hh" "${library_root}/address.hh"
"${library_root}/architecture.hh" "${library_root}/architecture.hh"
@@ -151,341 +144,17 @@ endif()
add_custom_target(sleigh_all_headers SOURCES ${public_include_header_list}) add_custom_target(sleigh_all_headers SOURCES ${public_include_header_list})
set(public_headers_dir ${CMAKE_CURRENT_BINARY_DIR}/include) set(public_headers_dir ${CMAKE_CURRENT_BINARY_DIR}/include)
file(MAKE_DIRECTORY "${public_headers_dir}/sleigh") file(MAKE_DIRECTORY "${public_headers_dir}/sleigh")
configure_file(cmake/libconfig.h.in include/sleigh/libconfig.h) configure_file(cmake/libconfig.h.in "${public_headers_dir}/sleigh/libconfig.h")
# Copy the public headers into our build directory so that we can control the layout. # Copy the public headers into our build directory so that we can control the layout.
# Ideally, we want to let people '#include <sleigh/{header}>' without installing sleigh # Ideally, we want to let people '#include <sleigh/{header}>' without installing sleigh
foreach(public_header ${public_include_header_list}) foreach(public_header ${public_include_header_list})
configure_file("${public_header}" "${public_headers_dir}/sleigh" COPYONLY) configure_file("${public_header}" "${public_headers_dir}/sleigh" COPYONLY)
endforeach() endforeach()
set(sleigh_core_source_list
"${library_root}/xml.cc"
"${library_root}/space.cc"
"${library_root}/float.cc"
"${library_root}/address.cc"
"${library_root}/pcoderaw.cc"
"${library_root}/translate.cc"
"${library_root}/opcodes.cc"
"${library_root}/globalcontext.cc"
)
if(sleigh_RELEASE_IS_HEAD)
list(APPEND sleigh_core_source_list
"${library_root}/marshal.cc"
)
endif()
set(sleigh_deccore_source_list
"${library_root}/capability.cc"
"${library_root}/architecture.cc"
"${library_root}/options.cc"
"${library_root}/graph.cc"
"${library_root}/cover.cc"
"${library_root}/block.cc"
"${library_root}/cast.cc"
"${library_root}/typeop.cc"
"${library_root}/database.cc"
"${library_root}/cpool.cc"
"${library_root}/comment.cc"
"${library_root}/stringmanage.cc"
"${library_root}/fspec.cc"
"${library_root}/action.cc"
"${library_root}/loadimage.cc"
"${library_root}/grammar.cc"
"${library_root}/varnode.cc"
"${library_root}/op.cc"
"${library_root}/type.cc"
"${library_root}/variable.cc"
"${library_root}/varmap.cc"
"${library_root}/jumptable.cc"
"${library_root}/emulate.cc"
"${library_root}/emulateutil.cc"
"${library_root}/flow.cc"
"${library_root}/userop.cc"
"${library_root}/funcdata.cc"
"${library_root}/funcdata_block.cc"
"${library_root}/funcdata_op.cc"
"${library_root}/funcdata_varnode.cc"
"${library_root}/pcodeinject.cc"
"${library_root}/heritage.cc"
"${library_root}/prefersplit.cc"
"${library_root}/rangeutil.cc"
"${library_root}/ruleaction.cc"
"${library_root}/subflow.cc"
"${library_root}/blockaction.cc"
"${library_root}/merge.cc"
"${library_root}/double.cc"
"${library_root}/transform.cc"
"${library_root}/coreaction.cc"
"${library_root}/condexe.cc"
"${library_root}/override.cc"
"${library_root}/dynamic.cc"
"${library_root}/crc32.cc"
"${library_root}/prettyprint.cc"
"${library_root}/printlanguage.cc"
"${library_root}/printc.cc"
"${library_root}/printjava.cc"
"${library_root}/memstate.cc"
"${library_root}/opbehavior.cc"
"${library_root}/paramid.cc"
)
if(sleigh_RELEASE_IS_HEAD)
list(APPEND sleigh_deccore_source_list
"${library_root}/unionresolve.cc"
)
endif()
set(sleigh_extra_source_list
"${library_root}/callgraph.cc"
"${library_root}/ifacedecomp.cc"
"${library_root}/ifaceterm.cc"
"${library_root}/inject_sleigh.cc"
"${library_root}/interface.cc"
"${library_root}/libdecomp.cc"
"${library_root}/loadimage_xml.cc"
"${library_root}/raw_arch.cc"
"${library_root}/rulecompile.cc"
"${library_root}/sleigh_arch.cc"
"${library_root}/testfunction.cc"
"${library_root}/unify.cc"
"${library_root}/xml_arch.cc"
)
set(sleigh_source_list
"${library_root}/sleigh.cc"
"${library_root}/pcodeparse.cc"
"${library_root}/pcodecompile.cc"
"${library_root}/sleighbase.cc"
"${library_root}/slghsymbol.cc"
"${library_root}/slghpatexpress.cc"
"${library_root}/slghpattern.cc"
"${library_root}/semantics.cc"
"${library_root}/context.cc"
"${library_root}/filemanage.cc"
)
set(sleigh_ghidra_source_list
"${library_root}/ghidra_arch.cc"
"${library_root}/inject_ghidra.cc"
"${library_root}/ghidra_translate.cc"
"${library_root}/loadimage_ghidra.cc"
"${library_root}/typegrp_ghidra.cc"
"${library_root}/database_ghidra.cc"
"${library_root}/ghidra_context.cc"
"${library_root}/cpool_ghidra.cc"
"${library_root}/ghidra_process.cc"
"${library_root}/comment_ghidra.cc"
"${library_root}/string_ghidra.cc"
)
set(sleigh_slacomp_source_list
"${library_root}/slgh_compile.cc"
"${library_root}/slghparse.cc"
"${library_root}/slghscan.cc"
)
# #
# sleigh settings # sla
# #
add_library(sleigh_settings INTERFACE) add_library(sleigh_sla
add_library(sleigh::sleigh_settings ALIAS sleigh_settings)
target_compile_features(sleigh_settings INTERFACE
cxx_std_11
)
set(sleigh_SPEC_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/share/sleigh/specfiles/")
set(sleigh_SPEC_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/specfiles/")
set_target_properties(sleigh_settings PROPERTIES
INTERFACE_POSITION_INDEPENDENT_CODE ON
)
if(sleigh_ENABLE_SANITIZERS)
message(STATUS "sleigh: Sanitizers have been enabled")
if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
message(WARNING "sleigh: Debug builds are preferred when sanitizers are enabled")
endif()
set(flag_list
-fno-omit-frame-pointer -fsanitize=undefined,address
)
target_compile_options(sleigh_settings INTERFACE ${flag_list})
target_link_options(sleigh_settings INTERFACE ${flag_list})
endif()
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
set(debug_setting_list
OPACTION_DEBUG
MERGEMULTI_DEBUG
BLOCKCONSISTENT_DEBUG
DFSVERIFY_DEBUG
)
foreach(debug_setting ${debug_setting_list})
if(NOT sleigh_${debug_setting})
continue()
endif()
message(STATUS "sleigh: Enabling debug setting: sleigh_${debug_setting}")
target_compile_definitions(sleigh_settings INTERFACE
${debug_setting}
)
endforeach()
endif()
set(internal_setting_list
CPUI_STATISTICS
CPUI_RULECOMPILE
)
foreach(internal_setting ${internal_setting_list})
if(NOT sleigh_${internal_setting})
continue()
endif()
message(STATUS "sleigh: Enabling internal setting: sleigh_${internal_setting}")
target_compile_definitions(sleigh_settings INTERFACE
${internal_setting}
)
endforeach()
#
# decomp_opt, decomp_dbg
#
add_executable(decomp_opt
${sleigh_core_source_list}
${sleigh_deccore_source_list}
${sleigh_extra_source_list}
${sleigh_source_list}
"${library_root}/consolemain.cc"
)
add_executable(sleigh::decomp_opt ALIAS decomp_opt)
if(NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
target_compile_definitions(decomp_opt PRIVATE
__TERMINAL__
)
endif()
target_link_libraries(decomp_opt PRIVATE
sleigh::sleigh_settings
)
target_include_directories(decomp_opt PRIVATE $<BUILD_INTERFACE:${library_root}>)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(decomp_opt PRIVATE
CPUI_DEBUG
)
set_target_properties(decomp_opt PROPERTIES
OUTPUT_NAME "decomp_dbg"
)
endif()
#
# ghidra_test_dbg
#
if(sleigh_ENABLE_TESTS)
add_executable(ghidra_test_dbg
${sleigh_core_source_list}
${sleigh_deccore_source_list}
${sleigh_source_list}
${sleigh_extra_source_list}
"${library_root}/test.cc"
"${library_root}/../unittests/testcirclerange.cc"
"${library_root}/../unittests/testfloatemu.cc"
"${library_root}/../unittests/testtypes.cc"
)
target_link_libraries(ghidra_test_dbg PRIVATE
sleigh::sleigh_settings
)
target_include_directories(ghidra_test_dbg PRIVATE $<BUILD_INTERFACE:${library_root}>)
if(NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
target_compile_definitions(ghidra_test_dbg PRIVATE
__TERMINAL__
)
endif()
add_test(
NAME ghidra_unittest_dbg
COMMAND ghidra_test_dbg -sleighpath "${CMAKE_CURRENT_BINARY_DIR}" unittests
)
add_test(
NAME ghidra_datatest_dbg
COMMAND ghidra_test_dbg -sleighpath "${CMAKE_CURRENT_BINARY_DIR}"
-path "${ghidrasource_SOURCE_DIR}/Ghidra/Features/Decompiler/src/decompile/datatests"
datatests
)
endif()
#
# ghidra_opt, ghidra_dbg
#
add_executable(ghidra_opt
${sleigh_core_source_list}
${sleigh_deccore_source_list}
${sleigh_ghidra_source_list}
)
add_executable(sleigh::ghidra_opt ALIAS ghidra_opt)
target_link_libraries(ghidra_opt PRIVATE
sleigh::sleigh_settings
)
target_include_directories(ghidra_opt PRIVATE $<BUILD_INTERFACE:${library_root}>)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_sources(ghidra_opt PRIVATE
"${library_root}/callgraph.cc"
"${library_root}/ifacedecomp.cc"
"${library_root}/ifaceterm.cc"
"${library_root}/interface.cc"
"${library_root}/testfunction.cc"
)
target_compile_definitions(ghidra_opt PRIVATE
CPUI_DEBUG
)
set_target_properties(ghidra_opt PROPERTIES
OUTPUT_NAME "ghidra_dbg"
)
endif()
#
# sleigh_opt, sleigh_dbg
#
add_executable(sleigh_opt
${sleigh_core_source_list}
${sleigh_source_list}
${sleigh_slacomp_source_list}
)
add_executable(sleigh::sleigh_opt ALIAS sleigh_opt)
target_link_libraries(sleigh_opt PRIVATE
sleigh::sleigh_settings
)
target_include_directories(sleigh_opt PRIVATE $<BUILD_INTERFACE:${library_root}>)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
set_target_properties(sleigh_opt PROPERTIES
OUTPUT_NAME "sleigh_dbg"
)
endif()
#
# sla, sla_dbg
#
add_library(sla
${sleigh_core_source_list} ${sleigh_core_source_list}
${sleigh_source_list} ${sleigh_source_list}
@@ -495,383 +164,110 @@ add_library(sla
"${library_root}/emulate.cc" "${library_root}/emulate.cc"
"${library_root}/opbehavior.cc" "${library_root}/opbehavior.cc"
) )
add_library(sleigh::sla ALIAS sla) add_library(sleigh::sla ALIAS sleigh_sla)
target_link_libraries(sla PUBLIC
sleigh::sleigh_settings
)
target_compile_features(sleigh_sla PUBLIC cxx_std_11)
# Private include search path '#include "..." # Private include search path '#include "..."
target_include_directories(sla PRIVATE $<BUILD_INTERFACE:${library_root}>) target_include_directories(sleigh_sla PRIVATE "$<BUILD_INTERFACE:${library_root}>")
# Public include search path in build directory # Public include search path in build directory
target_include_directories( target_include_directories(
sla SYSTEM sleigh_sla SYSTEM
INTERFACE $<BUILD_INTERFACE:${public_headers_dir}> INTERFACE "$<BUILD_INTERFACE:${public_headers_dir}>"
)
target_compile_definitions(sleigh_sla PRIVATE "$<$<CONFIG:Debug>:YYDEBUG>")
sleigh_add_optional_defines(sleigh_sla PUBLIC)
set_target_properties(sleigh_sla PROPERTIES
EXPORT_NAME sla
OUTPUT_NAME sla
OUTPUT_NAME_DEBUG sla_dbg
) )
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(sla PRIVATE
YYDEBUG
)
set_target_properties(sla PROPERTIES
OUTPUT_NAME "sla_dbg"
)
endif()
# #
# decomp, decomp_dbg # decomp
# #
add_library(decomp add_library(sleigh_decomp
${sleigh_core_source_list} ${sleigh_core_source_list}
${sleigh_deccore_source_list} ${sleigh_deccore_source_list}
${sleigh_extra_source_list} ${sleigh_extra_source_list}
${sleigh_source_list} ${sleigh_source_list}
) )
add_library(sleigh::decomp ALIAS decomp) add_library(sleigh::decomp ALIAS sleigh_decomp)
target_link_libraries(decomp PUBLIC
sleigh::sleigh_settings
)
target_compile_features(sleigh_decomp PUBLIC cxx_std_11)
# Private include search path '#include "..." # Private include search path '#include "..."
target_include_directories(decomp PRIVATE $<BUILD_INTERFACE:${library_root}>) target_include_directories(sleigh_decomp PRIVATE "$<BUILD_INTERFACE:${library_root}>")
# Public include search path in build directory # Public include search path in build directory
target_include_directories( target_include_directories(
decomp SYSTEM sleigh_decomp SYSTEM
INTERFACE $<BUILD_INTERFACE:${public_headers_dir}> INTERFACE "$<BUILD_INTERFACE:${public_headers_dir}>"
)
sleigh_add_optional_defines(sleigh_decomp PUBLIC)
set_target_properties(sleigh_decomp PROPERTIES
EXPORT_NAME decomp
OUTPUT_NAME decomp
OUTPUT_NAME_DEBUG decomp_dbg
) )
if(CMAKE_BUILD_TYPE STREQUAL "Debug") # This is the root directory where all individual processor spec file directories will be created.
set_target_properties(decomp PROPERTIES # NOTE: Needs to be defined here before the install rules
OUTPUT_NAME "decomp_dbg" set(spec_files_build_dir "${CMAKE_CURRENT_BINARY_DIR}/specfiles")
)
#
# Install rules
#
if(NOT CMAKE_SKIP_INSTALL_RULES)
include(cmake/install-rules.cmake)
endif() endif()
# #
# Documentation # Build tool projects
# #
if(sleigh_ENABLE_DOCUMENTATION) if(sleigh_BUILD_TOOLS)
message(STATUS "sleigh: Documentation has been enabled") add_subdirectory(tools)
find_package(Doxygen REQUIRED COMPONENTS dot)
set(documentation_output "${CMAKE_CURRENT_BINARY_DIR}/doc")
# Always run this target because we have no source file tracking for incremental builds
add_custom_target(sleigh_documentation
COMMAND "${CMAKE_COMMAND}" -E remove_directory "${library_root}/../doc" "${documentation_output}"
COMMAND Doxygen::doxygen Doxyfile
COMMAND "${CMAKE_COMMAND}" -E copy_directory "${library_root}/../doc" "${documentation_output}"
COMMENT "sleigh: Generating the Doxygen documentation"
WORKING_DIRECTORY "${library_root}"
VERBATIM
)
endif() endif()
# #
# Spec files # Spec files
# #
# Sets 'spec_file_list' variable if(sleigh_BUILD_SLEIGHSPECS)
if(sleigh_RELEASE_IS_HEAD) add_subdirectory(sleighspecs)
include(spec-files-list/spec_files_HEAD.cmake)
else()
include(spec-files-list/spec_files_stable.cmake)
endif() endif()
# This prefix should match the Ghidra repo to where the sla spec files are located
set(spec_files_dir_prefix Ghidra/Processors)
# This is the root directory where all individual processor spec file directories will be created
set(spec_files_build_dir "${CMAKE_CURRENT_BINARY_DIR}/specfiles")
# This is where we will be copying the generated artifacts for each processor
set(spec_files_root_dir "${spec_files_build_dir}/${spec_files_dir_prefix}")
set(spec_files_build_log_dir ${CMAKE_CURRENT_BINARY_DIR}/spec_build_logs)
add_custom_command(
OUTPUT ${spec_files_build_log_dir}
COMMAND ${CMAKE_COMMAND} -E make_directory ${spec_files_build_log_dir}
)
# Start processing all `.slaspec` files individually
set(spec_targets)
set(spec_files)
set(spec_dirs)
include(cmake/modules/sleighCompile.cmake)
# Example: '<ghidra_source_prefix>/Ghidra/Processors/8051/data/languages/mx51.slaspec'
foreach(spec_file ${spec_file_list})
# Get 'mx51'
get_filename_component(spec_name "${spec_file}" NAME_WLE)
# Get '<ghidra_source_prefix>/Ghidra/Processors/8051/data/languages'
get_filename_component(spec_dir "${spec_file}" DIRECTORY)
# Get '8051/data/languages'
file(RELATIVE_PATH spec_proc_dir
"${ghidrasource_SOURCE_DIR}/${spec_files_dir_prefix}"
"${spec_dir}"
)
# Add relative spec processor directory for later processing
list(APPEND spec_dirs ${spec_proc_dir})
# Get '8051'
get_filename_component(proc_name "${spec_proc_dir}" DIRECTORY)
get_filename_component(proc_name "${proc_name}" DIRECTORY)
set(spec_build_log "${spec_files_build_log_dir}/${spec_name}_build.log")
# Combine back again for the build directory output like
# '<build_prefix>/Ghidra/Processors/8051/data/languages'
set(spec_out_dir "${spec_files_root_dir}/${spec_proc_dir}")
# '<build_prefix>/Ghidra/Processors/8051/data/languages/mx51.sla'
set(spec_out "${spec_out_dir}/${spec_name}.sla")
string(REPLACE "." "_" spec_target_name ${spec_name})
set(spec_target "sleigh_spec_${spec_target_name}")
# Compile the sla file
sleigh_compile(
TARGET "${spec_target}"
COMPILER "$<TARGET_FILE:sleigh::sleigh_opt>"
SLASPEC "${spec_file}"
LOG_FILE "${spec_build_log}"
OUT_FILE "${spec_out}"
)
add_dependencies(${spec_target} sleigh_copy_${proc_name}_dir)
list(APPEND spec_targets ${spec_target})
list(APPEND spec_files ${spec_out})
endforeach()
# Copy and create specfile directories
list(REMOVE_DUPLICATES spec_dirs)
foreach(spec_dir ${spec_dirs})
set(spec_src_dir "${ghidrasource_SOURCE_DIR}/${spec_files_dir_prefix}/${spec_dir}")
set(spec_out_dir "${spec_files_root_dir}/${spec_dir}")
# Get the processor directory name
get_filename_component(proc_name "${spec_dir}" DIRECTORY)
get_filename_component(proc_name "${proc_name}" DIRECTORY)
# Copy all other files from the slaspec source directory:
# '<ghidra_source_prefix>/Ghidra/Processors/8051/data/languages'
# NOTE: This only copies the directory once, so you will need to remove the
# whole directory if you update any of the other files, like '*.cspec' or
# '*.ldef' files
# CMake only guarantees update monitoring for files listed explicitly
add_custom_command(
OUTPUT "${spec_out_dir}"
COMMAND ${CMAKE_COMMAND} -E copy_directory "${spec_src_dir}" "${spec_out_dir}"
)
add_custom_target(sleigh_copy_${proc_name}_dir
DEPENDS "${spec_out_dir}"
)
endforeach()
# All of the sla spec targets are combined into this one
add_custom_target(sleigh_all_sla_specs ALL DEPENDS
${spec_targets}
)
# #
# Examples # Included Example
# #
if(sleigh_ENABLE_EXAMPLES) if(PROJECT_IS_TOP_LEVEL)
add_executable(sleighexample include(CMakeDependentOption)
"${library_root}/sleighexample.cc" cmake_dependent_option(sleigh_BUILD_EXAMPLE "Build included sleigh example" "${sleigh_DEVELOPER_MODE}" "sleigh_BUILD_SLEIGHSPECS" OFF)
) if(sleigh_BUILD_EXAMPLE)
add_subdirectory(example)
target_link_libraries(sleighexample PRIVATE
sleigh::sla
sleigh::decomp
)
add_custom_target(sleighexample_runner
"${CMAKE_COMMAND}" -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/specfiles"
COMMAND "${CMAKE_COMMAND}" -E create_symlink "${spec_files_root_dir}/x86/data/languages/x86.sla" "${CMAKE_CURRENT_BINARY_DIR}/specfiles/x86.sla"
COMMAND sleighexample disassemble
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
)
add_dependencies(
sleighexample_runner
sleigh_spec_x86
)
endif()
# Add support library before configuring install targets
add_subdirectory(support)
#
# Install targets
#
if(NOT CMAKE_SKIP_INSTALL_RULES)
include("GNUInstallDirs")
install(
TARGETS
sleigh_settings
sla
decomp
support
decomp_opt
ghidra_opt
sleigh_opt
EXPORT
sleighTargets
INCLUDES DESTINATION
${CMAKE_INSTALL_INCLUDEDIR}
)
install(
DIRECTORY
"${CMAKE_CURRENT_BINARY_DIR}/include/"
DESTINATION
${CMAKE_INSTALL_INCLUDEDIR}
)
# Install the compiled sla files found in 'Ghidra' top-level directory
install(
DIRECTORY
"${spec_files_build_dir}"
DESTINATION
"${CMAKE_INSTALL_DATADIR}/sleigh"
)
set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/sleigh")
if(sleigh_ENABLE_DOCUMENTATION)
# Build docs during install
install(CODE
"execute_process(
COMMAND \"${CMAKE_COMMAND}\" --build \"${CMAKE_BINARY_DIR}\" --target sleigh_documentation
COMMAND_ECHO STDOUT
)"
)
install(
DIRECTORY
"${documentation_output}/html/"
DESTINATION
"${CMAKE_INSTALL_DOCDIR}"
)
endif(sleigh_ENABLE_DOCUMENTATION)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
set(output_folder_path "${CMAKE_CURRENT_BINARY_DIR}/symlinks")
add_custom_command(
OUTPUT "${output_folder_path}"
COMMAND "${CMAKE_COMMAND}" -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/symlinks"
COMMENT "sleigh: Generating symlink folder"
VERBATIM
)
add_custom_target(sleigh_symlinks_folder_builder DEPENDS
"${output_folder_path}"
)
add_custom_target(sleigh_symlinks_builder ALL)
foreach(target_name "decomp"
"ghidra"
"sleigh")
set(source_name "${target_name}_dbg")
set(destination_name "${target_name}_opt")
set(output_path "${output_folder_path}/${destination_name}")
add_custom_command(
OUTPUT "${output_path}"
COMMAND "${CMAKE_COMMAND}" -E create_symlink "${source_name}" "${destination_name}"
WORKING_DIRECTORY "${output_folder_path}"
COMMENT "sleigh: Generating executable symlink: ${source_name} -> ${destination_name}"
VERBATIM
)
set(target_name "sleigh_${source_name}_symlink_builder")
add_custom_target("${target_name}" DEPENDS
"${output_path}"
)
add_dependencies("${target_name}"
sleigh_symlinks_folder_builder
)
add_dependencies(sleigh_symlinks_builder
"${target_name}"
)
install(
FILES
"${output_path}"
DESTINATION
"${CMAKE_INSTALL_BINDIR}"
PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE
)
endforeach()
endif() endif()
set(
sleigh_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/sleigh"
CACHE PATH "CMake package config location relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_CMAKEDIR)
install(
EXPORT sleighTargets
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NAMESPACE sleigh::
)
# Specfiles installation setup
set(
sleigh_INSTALL_DATADIR "${CMAKE_INSTALL_DATADIR}/sleigh"
CACHE PATH "sleigh data installation location relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_DATADIR)
set(sleigh_INSTALL_SPECDIR "${sleigh_INSTALL_DATADIR}/specfiles"
CACHE PATH "sleigh specfile root destination relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_SPECDIR)
include(CMakePackageConfigHelpers)
configure_package_config_file(cmake/install-config.cmake.in
${PROJECT_BINARY_DIR}/install-config.cmake
INSTALL_DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NO_CHECK_REQUIRED_COMPONENTS_MACRO
PATH_VARS sleigh_INSTALL_SPECDIR
)
install(
FILES ${PROJECT_BINARY_DIR}/install-config.cmake
RENAME sleighConfig.cmake
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
)
install(
FILES cmake/modules/sleighCompile.cmake
DESTINATION "${sleigh_INSTALL_CMAKEDIR}/modules"
)
endif() endif()
add_subdirectory(tools) #
# Support library provided by Trail of Bits
#
if(sleigh_BUILD_SUPPORT)
# Add support library before configuring install targets
add_subdirectory(support)
endif()
#
# Extras provided by Trail of Bits
#
if(sleigh_BUILD_EXTRATOOLS)
add_subdirectory(extra-tools)
endif()
#
# Developer mode
#
if(NOT sleigh_DEVELOPER_MODE)
return()
elseif(NOT PROJECT_IS_TOP_LEVEL)
message(AUTHOR_WARNING "Developer mode is intended for developers of sleigh")
endif()
include(cmake/dev-mode.cmake)
CMakePresets.json
+130
View File
@@ -0,0 +1,130 @@
{
"version": 2,
"cmakeMinimumRequired": {
"major": 3,
"minor": 18,
"patch": 0
},
"configurePresets": [
{
"name": "cmake-pedantic",
"hidden": true,
"warnings": {
"dev": true,
"deprecated": true,
"uninitialized": true,
"unusedCli": true,
"systemVars": false
},
"errors": {
"dev": true,
"deprecated": true
}
},
{
"name": "dev-mode",
"hidden": true,
"inherits": "cmake-pedantic",
"cacheVariables": {
"sleigh_DEVELOPER_MODE": "ON",
"sleigh_BUILD_DOCUMENTATION": "ON"
}
},
{
"name": "ci-std",
"description": "This preset makes sure the project actually builds with at least the specified standard",
"hidden": true,
"cacheVariables": {
"CMAKE_CXX_EXTENSIONS": "OFF",
"CMAKE_CXX_STANDARD": "11",
"CMAKE_CXX_STANDARD_REQUIRED": "ON"
}
},
{
"name": "ci-std-tools",
"description": "This preset makes sure the project actually builds with at least the specified standard for extra sleigh tools",
"hidden": true,
"inherits": "ci-std",
"cacheVariables": {
"CMAKE_CXX_STANDARD": "17"
}
},
{
"name": "flags-unix",
"hidden": true,
"cacheVariables": {
"CMAKE_CXX_FLAGS": "-Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wcast-qual -Wshadow -Wformat=2 -Wundef"
}
},
{
"name": "flags-windows",
"description": "Note that all the flags after /W4 are required for MSVC to conform to the language standard",
"hidden": true,
"cacheVariables": {
"CMAKE_CXX_FLAGS": "/utf-8 /W4 /permissive- /volatile:iso /Zc:preprocessor /EHsc /Zc:__cplusplus /Zc:externConstexpr /Zc:throwingNew"
}
},
{
"name": "ci-unix",
"generator": "Unix Makefiles",
"hidden": true,
"inherits": ["flags-unix", "ci-std"],
"cacheVariables": {
"CMAKE_BUILD_TYPE": "RelWithDebInfo"
}
},
{
"name": "ci-win64",
"inherits": ["flags-windows", "ci-std"],
"generator": "Visual Studio 17 2022",
"architecture": "x64",
"hidden": true
},
{
"name": "coverage-unix",
"binaryDir": "${sourceDir}/build/coverage",
"inherits": "ci-unix",
"hidden": true,
"cacheVariables": {
"ENABLE_COVERAGE": "ON",
"CMAKE_BUILD_TYPE": "Coverage",
"CMAKE_CXX_FLAGS_COVERAGE": "-Og -g --coverage -fkeep-static-functions",
"CMAKE_EXE_LINKER_FLAGS_COVERAGE": "--coverage",
"CMAKE_SHARED_LINKER_FLAGS_COVERAGE": "--coverage"
}
},
{
"name": "ci-coverage",
"inherits": ["coverage-unix", "dev-mode"],
"cacheVariables": {
"COVERAGE_HTML_COMMAND": ""
}
},
{
"name": "ci-sanitize",
"binaryDir": "${sourceDir}/build/sanitize",
"inherits": ["ci-unix", "dev-mode"],
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Sanitize",
"CMAKE_CXX_FLAGS_SANITIZE": "-O2 -g -fsanitize=address,undefined -fno-omit-frame-pointer -fno-common"
}
},
{
"name": "ci-build",
"binaryDir": "${sourceDir}/build",
"hidden": true
},
{
"name": "ci-macos",
"inherits": ["ci-build", "ci-unix", "dev-mode"]
},
{
"name": "ci-ubuntu",
"inherits": ["ci-build", "ci-unix", "dev-mode"]
},
{
"name": "ci-windows",
"inherits": ["ci-build", "ci-win64", "dev-mode"]
}
]
}
README.md
+26 -28
View File
@@ -1,8 +1,8 @@
# SLEIGH Library # Sleigh Library
[SLEIGH](https://ghidra.re/courses/languages/html/sleigh.html) is a language used to describe the semantics of instruction sets of general-purpose microprocessors, with enough detail to facilitate the reverse engineering of software compiled for these architectures. It is part of the [GHIDRA reverse engineering platform](https://github.com/NationalSecurityAgency/ghidra), and underpins two of its major components: its disassembly and decompilation engines. [Sleigh](https://ghidra.re/courses/languages/html/sleigh.html) is a language used to describe the semantics of instruction sets of general-purpose microprocessors, with enough detail to facilitate the reverse engineering of software compiled for these architectures. It is part of the [Ghidra reverse engineering platform](https://github.com/NationalSecurityAgency/ghidra) and underpins two of its major components: its disassembly and decompilation engines.
This repository provides a CMake-based build project for SLEIGH so that it can be built and packaged as a standalone library, and be reused in projects other than GHIDRA. This repository provides a CMake-based build project for Sleigh so that it can be built and packaged as a standalone library and be reused in projects other than Ghidra.
## Supported Platforms ## Supported Platforms
@@ -32,49 +32,43 @@ For building documentation:
| [Doxygen](https://www.doxygen.nl/) | Latest | doxygen | doxygen | | [Doxygen](https://www.doxygen.nl/) | Latest | doxygen | doxygen |
| [GraphViz](https://graphviz.org/) | Latest | graphviz | graphviz | | [GraphViz](https://graphviz.org/) | Latest | graphviz | graphviz |
## Build and Install the SLEIGH Library ## Build and Install the Sleigh Library
```sh ```sh
# Clone this repository (CMake project for SLEIGH) # Clone this repository (CMake project for sleigh)
git clone https://github.com/lifting-bits/sleigh.git git clone https://github.com/lifting-bits/sleigh.git
cd sleigh cd sleigh
# Configure CMake # Configure CMake
cmake -B build -S . cmake -B build -S .
# Build SLEIGH # Build Sleigh
cmake --build build -j cmake --build build --parallel 8
# Install SLEIGH # Install Sleigh
cmake --install build --prefix <path where SLEIGH will install> cmake --install build --prefix ./install
``` ```
### Note on Ghidra source code ### Note on Ghidra source code
The Ghidra source code is not actually included in this git repo, and by default, CMake will automatically pull a stable version from the internet for you. The Ghidra source code is not actually included in this git repo, and by default, CMake will automatically pull a stable version from the internet for you.
Please see [`src/README.md`](./src/README.md) for more information on how to customize which Ghidra source code commit will be used/compiled, including specifying your own local copy of the Ghidra source. Please see [`src/README.md`](src/README.md) for more information on how to customize which Ghidra source code commit will be used/compiled, including specifying your own local copy of the Ghidra source.
## Packaging ## Packaging
The CMake configuration also supports building packages for SLEIGH. If the `sleigh_ENABLE_PACKAGING` option is set during the configuration step, the build step will generate a tarball containing the SLEIGH installation. Additionally, the build will create an RPM package if it finds `rpm` in the `PATH` and/or a DEB package if it finds `dpkg` in the `PATH`. The CMake configuration also supports building packages for Sleigh.
For example: For example:
```sh ```sh
cmake -B build -S . \ # Package Sleigh
-Dsleigh_ENABLE_PACKAGING=ON
# Build SLEIGH
cmake --build build -j
# Package SLEIGH
cmake --build build --target package cmake --build build --target package
``` ```
## API Usage ## API Usage
An example program called `sleigh-lift` has been included to demonstrate how to use the SLEIGH API. It takes a hexadecimal string of bytes and either disassembles it or lifts it to p-code. The program can be invoked like so, where the `action` argument must be either `disassemble` or `pcode`: An example program called `sleigh-lift` has been included to demonstrate how to use the Sleigh API. It takes a hexadecimal string of bytes and can disassemble it or lift it to p-code. The program can be invoked as follows, where the `action` argument must be either `disassemble` or `pcode`:
```sh ```sh
sleigh-lift [action] [sla_file] [bytes] [-a address] [-p root_sla_dir] [-s pspec_file] sleigh-lift [action] [sla_file] [bytes] [-a address] [-p root_sla_dir] [-s pspec_file]
@@ -102,11 +96,11 @@ $ sleigh-lift pcode x86-64.sla 4881ecc00f0000
(register,0x202,1) = INT_EQUAL (unique,0x12d00,1) (const,0x0,1) (register,0x202,1) = INT_EQUAL (unique,0x12d00,1) (const,0x0,1)
``` ```
The `sleigh_ENABLE_EXAMPLES` option must be set to `ON` during the configuration step in order to build `sleigh-lift`. If you do not want to build `sleigh-lift`, you must set the CMake variable `sleigh_BUILD_EXTRATOOLS` option to `OFF` during CMake configuration.
## Helpers ## Helpers
This repository contains a helper that is not part of SLEIGH/GHIDRA, which can be found under `support/`. It has the following signature and can help the user find the location of a given spec file on the system: This repository contains a helper not part of Sleigh/Ghidra, which you can find in the `support` directory. It has the following signature and can help the user find the location of a given spec file on the system:
```c++ ```c++
std::optional<std::filesystem::path> std::optional<std::filesystem::path>
@@ -115,20 +109,24 @@ FindSpecFile(std::string_view file_name,
gDefaultSearchPaths); gDefaultSearchPaths);
``` ```
The `sleigh::FindSpecFile` function will search the the paths provided by the user via the `search_paths` argument for a spec file with the name `file_name`. The default argument for `search_paths` is `sleigh::gDefaultSearchPaths` which contains the install/build directories that the CMake project was configured with as well as a set of common installation locations. The `sleigh::FindSpecFile` function will search the paths provided by the user via the `search_paths` argument for a spec file with the name `file_name`. The default argument for `search_paths` is `sleigh::gDefaultSearchPaths` which contains the install/build directories generated during CMake configuration and a set of common installation locations.
If you do not want to build the helpers, you must set the CMake variable `sleigh_BUILD_SUPPORT` option to `OFF` during CMake configuration.
## Integration as a Dependency ## Integration as a Dependency
An installation of sleigh provides a CMake interface that can be used to assist in building your project. An installation of Sleigh provides a CMake interface that you can use when building your project.
An example of how to use the CMake package config file can be found in the [find_package](tests/find_package/CMakeLists.txt) example. You can find an example of how to use the CMake package config file in the [find_package](tests/find_package/CMakeLists.txt) example.
We also provide a CMake helper function [`sleigh_compile`](cmake/modules/sleighCompile.cmake) to compile your own `.slaspec` files using the installed sleigh compiler from this project. We also provide a CMake helper function [`sleigh_compile`](cmake/modules/sleighCompile.cmake) to compile your `.slaspec` files using a sleigh compiler.
Lastly, the installed compiled sleigh files can be located through the CMake variable `sleigh_INSTALL_SPECDIR`, which is an absolute path to the root directory for where the compiled sleigh files are located---you should manually inspect this to know what to expect. You can find a more complex CMake example with compiling Sleigh specifications in the [`example`](example/CMakeLists.txt) directory, which uses the upstream-provided sleigh example source code.
Referencing the [CMake config file](cmake/install-config.cmake.in) is also suggested for learning more about the exposed CMake variables and modules. Lastly, you can locate the installed compiled sleigh files through the CMake variable `sleigh_INSTALL_SPECDIR`, which is an absolute path to the root directory for the compiled sleigh files---you should manually inspect this to know what to expect.
Referencing the [CMake config file](cmake/install-config.cmake.in) and [`specfiles` CMake file](sleighspecs/specfiles.cmake.in) is also suggested for learning more about the exposed CMake variables and modules.
## License ## License
See the LICENSE file in the top directory of this repo. See the [LICENSE file](LICENSE).
cmake/coverage.cmake
+33
View File
@@ -0,0 +1,33 @@
# ---- Variables ----
# We use variables separate from what CTest uses, because those have
# customization issues
set(
COVERAGE_TRACE_COMMAND
lcov -c -q
-o "${PROJECT_BINARY_DIR}/coverage.info"
-d "${PROJECT_BINARY_DIR}"
--include "${library_root}/*"
CACHE STRING
"; separated command to generate a trace for the 'coverage' target"
)
set(
COVERAGE_HTML_COMMAND
genhtml --legend -f -q
"${PROJECT_BINARY_DIR}/coverage.info"
-p "${library_root}"
-o "${PROJECT_BINARY_DIR}/coverage_html"
CACHE STRING
"; separated command to generate an HTML report for the 'coverage' target"
)
# ---- Coverage target ----
add_custom_target(
coverage
COMMAND ${COVERAGE_TRACE_COMMAND}
COMMAND ${COVERAGE_HTML_COMMAND}
COMMENT "Generating coverage report"
VERBATIM
)
cmake/dev-mode.cmake
+13
View File
@@ -0,0 +1,13 @@
include(CTest)
if(BUILD_TESTING)
add_subdirectory(tests)
endif()
if(sleigh_BUILD_DOCUMENTATION)
include(cmake/docs.cmake)
endif()
option(ENABLE_COVERAGE "Enable coverage support separate from CTest's" OFF)
if(ENABLE_COVERAGE)
include(cmake/coverage.cmake)
endif()
cmake/docs.cmake
+11
View File
@@ -0,0 +1,11 @@
find_package(Doxygen REQUIRED COMPONENTS dot)
# Always run this target because we have no source file tracking for incremental builds
add_custom_target(docs
COMMAND "${CMAKE_COMMAND}" -E remove_directory "${DOXYGEN_OUTPUT_DIRECTORY}/html"
COMMAND Doxygen::doxygen Doxyfile
COMMAND "${CMAKE_COMMAND}" -E copy_directory "${library_root}/../doc" "${DOXYGEN_OUTPUT_DIRECTORY}"
COMMENT "sleigh: Generating the Doxygen documentation"
WORKING_DIRECTORY "${library_root}"
VERBATIM
)
cmake/install-config.cmake.in
+43 -3
View File
@@ -1,12 +1,52 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
# This file provides access to the installed sleigh targets.
#
# There are optional components that could also be installed:
# * Specs - Compiled sleigh specification files
# * Support - Support library for easier use of sleigh
# * ExtraTools - Extra tools created by Trail of Bits
@PACKAGE_INIT@ @PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/sleighTargets.cmake") include("${CMAKE_CURRENT_LIST_DIR}/sleighTargets.cmake")
# Path relative-root to reach installed specfiles directory
set_and_check(sleigh_INSTALL_SPECDIR "@PACKAGE_sleigh_INSTALL_SPECDIR@")
# Extra version details. Either 'stable' or 'HEAD' # Extra version details. Either 'stable' or 'HEAD'
set(sleigh_RELEASE_IS_HEAD "@sleigh_RELEASE_IS_HEAD@") set(sleigh_RELEASE_IS_HEAD "@sleigh_RELEASE_IS_HEAD@")
# Helpers exposed by default when finding sleigh # Helpers exposed by default when finding sleigh
include("${CMAKE_CURRENT_LIST_DIR}/modules/sleighCompile.cmake") include("${CMAKE_CURRENT_LIST_DIR}/modules/sleighCompile.cmake")
# Find-package component handling for Support library and ExtraTools
set(_sleigh_supported_components Specs Support ExtraTools)
# Specs just sets a variable to the directory of installation
set(_sleigh_Specs_targets "${CMAKE_CURRENT_LIST_DIR}/specfiles.cmake")
set(_sleigh_Support_targets "${CMAKE_CURRENT_LIST_DIR}/sleighSupportTargets.cmake")
set(_sleigh_ExtraTools_targets "${CMAKE_CURRENT_LIST_DIR}/sleighExtraToolsTargets.cmake")
macro(sleigh_load_component comp)
if(NOT EXISTS "${_sleigh_${comp}_targets}" AND ${sleigh_FIND_REQUIRED_${comp}})
set(sleigh_NOT_FOUND_MESSAGE
"sleigh `${comp}` component targets were requested but not found.")
set(sleigh_FOUND FALSE)
return()
endif()
if(EXISTS "${_sleigh_${comp}_targets}")
include("${_sleigh_${comp}_targets}")
endif()
endmacro()
foreach(_comp ${sleigh_FIND_COMPONENTS})
if (NOT _comp IN_LIST _sleigh_supported_components)
set(sleigh_FOUND FALSE)
set(sleigh_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}")
endif()
sleigh_load_component("${_comp}")
endforeach()
cmake/install-rules.cmake
+93
View File
@@ -0,0 +1,93 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
if(PROJECT_IS_TOP_LEVEL)
set(CMAKE_INSTALL_INCLUDEDIR include/sleigh CACHE PATH "")
endif()
include(GNUInstallDirs)
install(
TARGETS
sleigh_sla
sleigh_decomp
EXPORT
sleighTargets
RUNTIME #
COMPONENT sleigh_Runtime
LIBRARY #
COMPONENT sleigh_Runtime
NAMELINK_COMPONENT sleigh_Development
ARCHIVE #
COMPONENT sleigh_Development
INCLUDES DESTINATION
"${CMAKE_INSTALL_INCLUDEDIR}"
)
install(
DIRECTORY "${public_headers_dir}/"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
COMPONENT sleigh_Development
)
if(sleigh_BUILD_DOCUMENTATION)
install(
DIRECTORY "${DOXYGEN_OUTPUT_DIRECTORY}/html/"
DESTINATION "${CMAKE_INSTALL_DOCDIR}"
COMPONENT sleigh_Documentation
)
endif()
set(
sleigh_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/sleigh"
CACHE PATH "CMake package config location relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_CMAKEDIR)
install(
EXPORT sleighTargets
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NAMESPACE sleigh::
COMPONENT sleigh_Development
)
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
"sleighConfigVersion.cmake"
COMPATIBILITY SameMinorVersion
)
install(
FILES "${PROJECT_BINARY_DIR}/sleighConfigVersion.cmake"
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
COMPONENT sleigh_Development
)
configure_package_config_file(cmake/install-config.cmake.in
"${PROJECT_BINARY_DIR}/install-config.cmake"
INSTALL_DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NO_CHECK_REQUIRED_COMPONENTS_MACRO
)
install(
FILES "${PROJECT_BINARY_DIR}/install-config.cmake"
RENAME sleighConfig.cmake
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
COMPONENT sleigh_Development
)
install(
FILES cmake/modules/sleighCompile.cmake
DESTINATION "${sleigh_INSTALL_CMAKEDIR}/modules"
COMPONENT sleigh_Development
)
if(PROJECT_IS_TOP_LEVEL)
include(cmake/packaging.cmake)
endif()
cmake/libconfig.h.in
+8
View File
@@ -1,3 +1,11 @@
/*
Copyright (c) 2022-present, Trail of Bits, Inc.
All rights reserved.
This source code is licensed in accordance with the terms specified in
the LICENSE file found in the root directory of this source tree.
*/
#ifndef SLEIGH_LIBCONFIG_H #ifndef SLEIGH_LIBCONFIG_H
#define SLEIGH_LIBCONFIG_H #define SLEIGH_LIBCONFIG_H
cmake/options.cmake
+26 -20
View File
@@ -6,29 +6,35 @@
# the LICENSE file found in the root directory of this source tree. # the LICENSE file found in the root directory of this source tree.
# #
option(sleigh_ENABLE_TESTS "Set to true to enable tests" ON) # ---- Developer mode ----
option(sleigh_ENABLE_EXAMPLES "Set to true to build examples" ON)
option(sleigh_ENABLE_DOCUMENTATION "Set to true to enable the documentation")
option(sleigh_ENABLE_PACKAGING "Set to true to enable packaging")
option(sleigh_ENABLE_SANITIZERS "Set to true to enable sanitizers")
set(sleigh_ADDITIONAL_PATCHES "" CACHE STRING
"The accepted patch format is git patch files, to be applied via git am. The format of the list is a CMake semicolon separated list.")
# Internal debug settings # Developer mode enables targets and code paths in the CMake scripts that are
option(sleigh_OPACTION_DEBUG "Turns on all the action tracing facilities") # only relevant for the developer(s) of sleigh
option(sleigh_MERGEMULTI_DEBUG "Check for MULTIEQUAL and INDIRECT intersections") # Targets necessary to build the project must be provided unconditionally, so
option(sleigh_BLOCKCONSISTENT_DEBUG "Check that block graph structure is consistent") # consumers can trivially build and package the project
option(sleigh_DFSVERIFY_DEBUG "Make sure that the block ordering algorithm produces a true depth first traversal of the dominator tree") if(PROJECT_IS_TOP_LEVEL)
option(sleigh_DEVELOPER_MODE "Enable developer mode")
# Additional internal settings option(BUILD_SHARED_LIBS "Build shared libs. (Untested and not supported)")
option(sleigh_CPUI_STATISTICS "Turn on collection of cover and cast statistics")
option(sleigh_CPUI_RULECOMPILE "Allow user defined dynamic rules")
# Sanity checking
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
set(sleigh_ENABLE_DOCUMENTATION OFF CACHE BOOL "Unsupported on Windows" FORCE)
endif() endif()
if(sleigh_DEVELOPER_MODE)
option(sleigh_BUILD_DOCUMENTATION "Build documentation using Doxygen")
set(
DOXYGEN_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/docs"
CACHE PATH "Path for the generated Doxygen documentation"
)
endif()
include(CMakeDependentOption)
# Optional project target building
option(sleigh_BUILD_TOOLS "Build and install executable tools" "${PROJECT_IS_TOP_LEVEL}")
option(sleigh_BUILD_SLEIGHSPECS "Build and install sleigh spec files" "${PROJECT_IS_TOP_LEVEL}")
# Add-ons by ToB
option(sleigh_BUILD_SUPPORT "Build ToB support libraries" "${PROJECT_IS_TOP_LEVEL}")
cmake_dependent_option(sleigh_BUILD_EXTRATOOLS "Build extra ToB sleigh tools" "${PROJECT_IS_TOP_LEVEL}" "sleigh_BUILD_SUPPORT" OFF)
# ---- Warning guard ---- # ---- Warning guard ----
# target_include_directories with the SYSTEM modifier will request the compiler # target_include_directories with the SYSTEM modifier will request the compiler
cmake/packaging.cmake
+26 -29
View File
@@ -11,44 +11,41 @@ if("${sleigh_RELEASE_TYPE}" STREQUAL "HEAD")
set(PACKAGE_VERSION "DEV.${ghidra_short_commit}") set(PACKAGE_VERSION "DEV.${ghidra_short_commit}")
endif() endif()
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "SLEIGH was designed for the GHIDRA reverse engineering platform built by the National Security Agency and is used to describe microprocessors with enough detail to facilitate two major components of GHIDRA, the disassembly and decompilation engines. This is an unofficial release by Trail of Bits.") set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sleigh was designed for the Ghidra reverse engineering platform built by the National Security Agency and is used to describe microprocessors with enough detail to facilitate two major components of Ghidra, the disassembly and decompilation engines. This is an unofficial release by Trail of Bits.")
set(CPACK_PACKAGE_NAME "sleigh") set(CPACK_PACKAGE_NAME "sleigh")
set(CPACK_PACKAGE_VENDOR "Trail of Bits") set(CPACK_PACKAGE_VENDOR "Trail of Bits")
set(CPACK_PACKAGE_CONTACT "info@trailofbits.com") set(CPACK_PACKAGE_CONTACT "info@trailofbits.com")
set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/lifting-bits/sleigh") set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/lifting-bits/sleigh")
set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${PROJECT_VERSION}-${PACKAGE_VERSION}.x86_64") set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${PROJECT_VERSION}-${PACKAGE_VERSION}.${CMAKE_SYSTEM_PROCESSOR}")
set(CPACK_PACKAGE_RELOCATABLE ON) set(CPACK_PACKAGE_RELOCATABLE ON)
set(CPACK_DEBIAN_PACKAGE_RELEASE "${PACKAGE_VERSION}")
set(CPACK_DEBIAN_PACKAGE_PRIORITY "extra")
set(CPACK_DEBIAN_PACKAGE_SECTION "default")
set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "${CPACK_PACKAGE_HOMEPAGE_URL}")
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc-dev-bin (>=2.31)")
set(CPACK_RPM_PACKAGE_RELEASE_DIST "${PACKAGE_VERSION}")
set(CPACK_RPM_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
set(CPACK_RPM_PACKAGE_GROUP "default")
set(CPACK_RPM_PACKAGE_REQUIRES "glibc >= 2.31")
set(CPACK_GENERATOR "TGZ") set(CPACK_GENERATOR "TGZ")
unset(rpm_executable_path CACHE) if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
find_program(rpm_executable_path "rpm") unset(rpm_executable_path CACHE)
if("${rpm_executable_path}" STREQUAL "rpm_executable_path-NOTFOUND") find_program(rpm_executable_path "rpm")
message(WARNING "sleigh: the RPM package generator requires the 'rpm' tool") if("${rpm_executable_path}" STREQUAL "rpm_executable_path-NOTFOUND")
message(WARNING "sleigh: the RPM package generator requires the 'rpm' tool")
else()
list(APPEND CPACK_GENERATOR "RPM")
message(STATUS "sleigh: the RPM generator has been enabled")
endif()
set(CPACK_RPM_PACKAGE_RELEASE_DIST "${PACKAGE_VERSION}")
set(CPACK_RPM_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
set(CPACK_RPM_PACKAGE_GROUP "default")
else() unset(dpkg_executable_path CACHE)
list(APPEND CPACK_GENERATOR "RPM") find_program(dpkg_executable_path "dpkg")
message(STATUS "sleigh: the RPM generator has been enabled") if("${dpkg_executable_path}" STREQUAL "dpkg_executable_path-NOTFOUND")
endif() message(WARNING "sleigh: the DEB package generator requires the 'dpkg' tool")
else()
unset(dpkg_executable_path CACHE) list(APPEND CPACK_GENERATOR "DEB")
find_program(dpkg_executable_path "dpkg") message(STATUS "sleigh: the DEB generator has been enabled")
if("${dpkg_executable_path}" STREQUAL "dpkg_executable_path-NOTFOUND") endif()
message(WARNING "sleigh: the DEB package generator requires the 'dpkg' tool") set(CPACK_DEBIAN_PACKAGE_RELEASE "${PACKAGE_VERSION}")
else() set(CPACK_DEBIAN_PACKAGE_PRIORITY "extra")
list(APPEND CPACK_GENERATOR "DEB") set(CPACK_DEBIAN_PACKAGE_SECTION "default")
message(STATUS "sleigh: the DEB generator has been enabled") set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "${CPACK_PACKAGE_HOMEPAGE_URL}")
endif() endif()
include(CPack) include(CPack)
cmake/prelude.cmake
+10
View File
@@ -0,0 +1,10 @@
# ---- In-source guard ----
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
message(
FATAL_ERROR
"In-source builds are not supported. "
"Please read the documentation before trying to build this project. "
"You may need to delete 'CMakeCache.txt' and 'CMakeFiles/' first."
)
endif()
cmake/project-is-top-level.cmake
+6
View File
@@ -0,0 +1,6 @@
# This variable is set by project() in CMake 3.21+
string(
COMPARE EQUAL
"${CMAKE_SOURCE_DIR}" "${PROJECT_SOURCE_DIR}"
PROJECT_IS_TOP_LEVEL
)
example/CMakeLists.txt
+115
View File
@@ -0,0 +1,115 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
cmake_minimum_required(VERSION 3.18)
include(../cmake/prelude.cmake)
# We include this because the source code for this example is in upstream
include(../src/setup-ghidra-source.cmake)
project(sleigh_example
VERSION "${ghidra_version}"
DESCRIPTION "Sleigh example"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
LANGUAGES CXX
)
include(../cmake/project-is-top-level.cmake)
if(NOT TARGET sleigh::sla)
find_package(sleigh)
if(NOT sleigh_FOUND)
message(WARNING "Could not find sleigh library, building from source")
# Exclude from all because there are no install rules for the example
# See sleigh-lift for example with install rules
add_subdirectory(.. sleigh EXCLUDE_FROM_ALL)
endif()
endif()
add_executable(sleigh_example
"${library_root}/sleighexample.cc"
)
target_compile_features(sleigh_example PRIVATE cxx_std_11)
sleigh_add_optional_defines(sleigh_example PRIVATE)
target_link_libraries(sleigh_example PRIVATE
sleigh::sla
)
set_target_properties(sleigh_example PROPERTIES
OUTPUT_NAME sleighexample
)
#
# Compile our required sleigh spec file
#
# Get the native machine's sleigh compiler or use the one we're about to build
# if not cross compiling
if(CMAKE_CROSSCOMPILING)
find_program(
SLEIGH_EXECUTABLE sleigh
DOC "Path to host system sleigh compiler"
REQUIRED
)
set(sleigh_compiler "${SLEIGH_EXECUTABLE}")
else()
# Try to find/acquire or bootstrap the sleigh spec compiler
# Logic is repeated in sleighspecs/CMakeLists.txt
if(NOT TARGET sleigh::sleigh)
find_package(sleigh QUIET)
if(NOT sleigh_FOUND OR NOT TARGET sleigh::sleigh)
find_program(
SLEIGH_EXECUTABLE sleigh
DOC "Path to host system sleigh compiler"
)
if(NOT SLEIGH_EXECUTABLE)
message(WARNING "Could not find sleigh compiler, building from source")
set(saved_skip_install_rules "${CMAKE_SKIP_INSTALL_RULES}")
set(CMAKE_SKIP_INSTALL_RULES TRUE)
add_subdirectory(../tools/spec-compiler spec-compiler EXCLUDE_FROM_ALL)
set(CMAKE_SKIP_INSTALL_RULES "${saved_skip_install_rules}")
endif()
endif()
endif()
endif()
if(SLEIGH_EXECUTABLE)
set(sleigh_compiler "${SLEIGH_EXECUTABLE}")
else()
set(sleigh_compiler "$<TARGET_FILE:sleigh::sleigh>")
endif()
# Compile the sla file
include(../cmake/modules/sleighCompile.cmake)
sleigh_compile(
TARGET sleigh_example_sleigh_spec_x86
COMPILER "${sleigh_compiler}"
SLASPEC "${ghidrasource_SOURCE_DIR}/Ghidra/Processors/x86/data/languages/x86.slaspec"
LOG_FILE "${CMAKE_CURRENT_BINARY_DIR}/specfiles/x86.sla.log"
OUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/specfiles/x86.sla"
)
set_property(
TARGET sleigh_example_sleigh_spec_x86
PROPERTY EXCLUDE_FROM_ALL FALSE
)
#
# Run the example
#
add_custom_target(sleigh_example_runner)
set(example_actions disassemble pcode emulate)
foreach(action ${example_actions})
add_custom_target(sleigh_example_${action}
COMMAND sleigh_example ${action}
COMMENT "Running example ${action}"
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
)
add_dependencies(sleigh_example_${action} sleigh_example_sleigh_spec_x86)
add_dependencies(sleigh_example_runner sleigh_example_${action})
endforeach()
extra-tools/CMakeLists.txt
+9
View File
@@ -0,0 +1,9 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
add_subdirectory(sleigh-lift)
extra-tools/sleigh-lift/CMakeLists.txt
+63
View File
@@ -0,0 +1,63 @@
#
# Copyright (c) 2021-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
cmake_minimum_required(VERSION 3.18)
project(sleighLift CXX)
set(build_from_source FALSE)
if(NOT TARGET sleigh::support)
find_package(sleigh)
if(NOT sleigh_FOUND)
message(WARNING "Could not find sleigh, building from source")
set(sleigh_BUILD_SUPPORT ON CACHE BOOL "" FORCE)
set(sleigh_BUILD_SLEIGHSPECS ON CACHE BOOL "" FORCE)
add_subdirectory(../.. sleigh)
else()
find_package(sleigh REQUIRED COMPONENTS Support Specs)
endif()
endif()
add_executable(sleigh_lift
src/main.cpp
)
add_executable(sleigh::lift ALIAS sleigh_lift)
target_link_libraries(sleigh_lift PRIVATE
sleigh::sla
sleigh::decomp
sleigh::support
)
target_compile_features(sleigh_lift PRIVATE cxx_std_17)
set_target_properties(sleigh_lift PROPERTIES
EXPORT_NAME lift
OUTPUT_NAME sleigh-lift
)
if(NOT CMAKE_SKIP_INSTALL_RULES)
include(GNUInstallDirs)
set(
sleigh_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/sleigh"
CACHE PATH "CMake package config location relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_CMAKEDIR)
install(
TARGETS sleigh_lift
EXPORT sleighExtraToolsTargets
RUNTIME #
COMPONENT sleigh_ExtraToolsRuntime
)
install(
EXPORT sleighExtraToolsTargets
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NAMESPACE sleigh::
COMPONENT sleigh_ExtraToolsDevelopment
)
endif()
tools/sleigh-lift/src/main.cpp → extra-tools/sleigh-lift/src/main.cpp
+2 -2
View File
@@ -256,7 +256,7 @@ int main(int argc, char *argv[]) {
<< std::endl; << std::endl;
return EXIT_FAILURE; return EXIT_FAILURE;
} }
// Put together SLEIGH components // Put together Sleigh components
#ifdef sleigh_RELEASE_IS_HEAD #ifdef sleigh_RELEASE_IS_HEAD
AttributeId::initialize(); AttributeId::initialize();
ElementId::initialize(); ElementId::initialize();
@@ -328,7 +328,7 @@ int main(int argc, char *argv[]) {
} }
// In order to parse and validate the byte string properly, we need to get the // In order to parse and validate the byte string properly, we need to get the
// address size from SLEIGH. Therefore this needs to happen after // address size from Sleigh. Therefore this needs to happen after
// initialization. // initialization.
// //
// Ensure that we don't start disassembling until we've set the image buffer. // Ensure that we don't start disassembling until we've set the image buffer.
scripts/update_ghidra_head.py
+1 -1
View File
@@ -8,7 +8,7 @@ import tempfile
from typing import AnyStr, Union from typing import AnyStr, Union
PROJECT_ROOT = pathlib.Path(__file__).parent.parent.resolve() PROJECT_ROOT = pathlib.Path(__file__).parent.parent.resolve()
HEAD_SPEC_FILE = PROJECT_ROOT / "spec-files-list" / "spec_files_HEAD.cmake" HEAD_SPEC_FILE = PROJECT_ROOT / "src" / "spec_files_HEAD.cmake"
assert HEAD_SPEC_FILE.exists() assert HEAD_SPEC_FILE.exists()
SETUP_GHIDRA_FILE = PROJECT_ROOT / "src" / "setup-ghidra-source.cmake" SETUP_GHIDRA_FILE = PROJECT_ROOT / "src" / "setup-ghidra-source.cmake"
assert SETUP_GHIDRA_FILE.exists() assert SETUP_GHIDRA_FILE.exists()
sleighspecs/CMakeLists.txt
+203
View File
@@ -0,0 +1,203 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
cmake_minimum_required(VERSION 3.18)
include(../cmake/prelude.cmake)
include(../src/setup-ghidra-source.cmake)
project(sleigh_specs
VERSION "${ghidra_version}"
DESCRIPTION "Sleigh specifications"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
# Language is for installing the helper CMake file
LANGUAGES CXX
)
include(../cmake/project-is-top-level.cmake)
# This is the root directory where all individual processor spec file directories will be created.
if(NOT DEFINED spec_files_build_dir)
set(spec_files_build_dir "${CMAKE_CURRENT_BINARY_DIR}/specfiles")
endif()
# This prefix should match the Ghidra repo to where the sla spec files are located
set(spec_files_dir_prefix "Ghidra/Processors")
# This is where we will be copying the generated artifacts for each processor
set(spec_files_root_dir "${spec_files_build_dir}/${spec_files_dir_prefix}")
set(spec_files_build_log_dir "${CMAKE_CURRENT_BINARY_DIR}/spec_build_logs")
add_custom_command(
OUTPUT "${spec_files_build_log_dir}"
COMMAND ${CMAKE_COMMAND} -E make_directory "${spec_files_build_log_dir}"
)
# Get the native machine's sleigh compiler or use the one we're about to build
# if not cross compiling
if(CMAKE_CROSSCOMPILING)
find_program(
SLEIGH_EXECUTABLE sleigh
DOC "Path to host system sleigh compiler"
REQUIRED
)
else()
# Try to find/acquire or bootstrap the sleigh spec compiler
# Logic is repeated in example/CMakeLists.txt
if(NOT TARGET sleigh::sleigh)
find_package(sleigh QUIET)
if(NOT sleigh_FOUND OR NOT TARGET sleigh::sleigh)
find_program(
SLEIGH_EXECUTABLE sleigh
DOC "Path to host system sleigh compiler"
)
if(NOT SLEIGH_EXECUTABLE)
message(WARNING "Could not find sleigh compiler, building from source")
set(saved_skip_install_rules "${CMAKE_SKIP_INSTALL_RULES}")
set(CMAKE_SKIP_INSTALL_RULES TRUE)
add_subdirectory(../tools/spec-compiler spec-compiler EXCLUDE_FROM_ALL)
set(CMAKE_SKIP_INSTALL_RULES "${saved_skip_install_rules}")
endif()
endif()
endif()
endif()
if(SLEIGH_EXECUTABLE)
set(sleigh_compiler "${SLEIGH_EXECUTABLE}")
else()
set(sleigh_compiler "$<TARGET_FILE:sleigh::sleigh>")
endif()
# Start processing all `.slaspec` files individually
set(spec_targets)
set(spec_files)
set(spec_dirs)
include(../cmake/modules/sleighCompile.cmake)
# Example: '<ghidra_source_prefix>/Ghidra/Processors/8051/data/languages/mx51.slaspec'
foreach(spec_file ${spec_file_list})
# Get 'mx51'
get_filename_component(spec_name "${spec_file}" NAME_WLE)
# Get '<ghidra_source_prefix>/Ghidra/Processors/8051/data/languages'
get_filename_component(spec_dir "${spec_file}" DIRECTORY)
# Get '8051/data/languages'
file(RELATIVE_PATH spec_proc_dir
"${ghidrasource_SOURCE_DIR}/${spec_files_dir_prefix}"
"${spec_dir}"
)
# Add relative spec processor directory for later processing
list(APPEND spec_dirs ${spec_proc_dir})
# Get '8051'
get_filename_component(proc_name "${spec_proc_dir}" DIRECTORY)
get_filename_component(proc_name "${proc_name}" DIRECTORY)
set(spec_build_log "${spec_files_build_log_dir}/${spec_name}_build.log")
# Combine back again for the build directory output like
# '<build_prefix>/Ghidra/Processors/8051/data/languages'
set(spec_out_dir "${spec_files_root_dir}/${spec_proc_dir}")
# '<build_prefix>/Ghidra/Processors/8051/data/languages/mx51.sla'
set(spec_out "${spec_out_dir}/${spec_name}.sla")
string(REPLACE "." "_" spec_target_name ${spec_name})
set(spec_target "sleigh_spec_${spec_target_name}")
# Compile the sla file
sleigh_compile(
TARGET "${spec_target}"
COMPILER "${sleigh_compiler}"
SLASPEC "${spec_file}"
LOG_FILE "${spec_build_log}"
OUT_FILE "${spec_out}"
)
add_dependencies(${spec_target} sleigh_copy_${proc_name}_dir)
list(APPEND spec_targets ${spec_target})
list(APPEND spec_files ${spec_out})
endforeach()
# Copy and create specfile directories
list(REMOVE_DUPLICATES spec_dirs)
foreach(spec_dir ${spec_dirs})
set(spec_src_dir "${ghidrasource_SOURCE_DIR}/${spec_files_dir_prefix}/${spec_dir}")
set(spec_out_dir "${spec_files_root_dir}/${spec_dir}")
# Get the processor directory name
get_filename_component(proc_name "${spec_dir}" DIRECTORY)
get_filename_component(proc_name "${proc_name}" DIRECTORY)
# Copy all other files from the slaspec source directory:
# '<ghidra_source_prefix>/Ghidra/Processors/8051/data/languages'
# NOTE: This only copies the directory once, so you will need to remove the
# whole directory if you update any of the other files, like '*.cspec' or
# '*.ldef' files
# CMake only guarantees update monitoring for files listed explicitly
add_custom_command(
OUTPUT "${spec_out_dir}"
COMMAND ${CMAKE_COMMAND} -E copy_directory "${spec_src_dir}" "${spec_out_dir}"
)
add_custom_target(sleigh_copy_${proc_name}_dir
DEPENDS "${spec_out_dir}"
)
endforeach()
# All of the sla spec targets are combined into this one
add_custom_target(sleigh_all_sla_specs ALL DEPENDS
${spec_targets}
)
if(NOT CMAKE_SKIP_INSTALL_RULES)
include(GNUInstallDirs)
# Specfiles installation setup
set(sleigh_INSTALL_DATADIR "${CMAKE_INSTALL_DATADIR}/sleigh"
CACHE PATH "sleigh data installation location relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_DATADIR)
set(sleigh_INSTALL_SPECDIR "${sleigh_INSTALL_DATADIR}/specfiles"
CACHE PATH "sleigh specfile root destination relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_SPECDIR)
# Install the compiled sla files found in 'Ghidra' top-level directory
install(
DIRECTORY "${spec_files_build_dir}/"
DESTINATION "${sleigh_INSTALL_SPECDIR}"
COMPONENT sleigh_Runtime
)
set(
sleigh_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/sleigh"
CACHE PATH "CMake package config location relative to the install prefix"
)
mark_as_advanced(sleigh_INSTALL_CMAKEDIR)
include(CMakePackageConfigHelpers)
configure_package_config_file(specfiles.cmake.in
"${PROJECT_BINARY_DIR}/specfiles.cmake"
INSTALL_DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NO_CHECK_REQUIRED_COMPONENTS_MACRO
PATH_VARS sleigh_INSTALL_SPECDIR
)
install(
FILES "${PROJECT_BINARY_DIR}/specfiles.cmake"
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
COMPONENT sleigh_Development
)
if(PROJECT_IS_TOP_LEVEL)
include(CPack)
endif()
endif()
sleighspecs/specfiles.cmake.in
+12
View File
@@ -0,0 +1,12 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
@PACKAGE_INIT@
# Path relative-root to reach installed specfiles directory
set_and_check(sleigh_INSTALL_SPECDIR "@PACKAGE_sleigh_INSTALL_SPECDIR@")
src/README.md
+21 -21
View File
@@ -1,45 +1,45 @@
# Ghidra Source code # Ghidra Source code
This project uses CMake's [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html) module to set up the Ghidra source tree. This means we can apply [patches](../patches) that live only in this repo for small changes to features like packaging or running tests. This project uses CMake's [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html) module to set up the Ghidra source tree. Using `FetchContent` means we can apply [patches](patches) that live only in this repo for minor changes that affect usage, packaging, or running tests.
By default, CMake pulls a stable version of Ghidra. You may use a more recent commit by specifying `-Dsleigh_GHIDRA_RELEASE_TYPE=HEAD` during CMake configuration. By default, CMake pulls a stable version of Ghidra. During CMake configuration, you may use a more recent commit by specifying `-Dsleigh_RELEASE_TYPE=HEAD`.
See the `sleigh_GHIDRA_*` CMake cache variable comments for more details on how to customize your Ghidra source checkout.
## Advanced Usage Notes ## Advanced Usage Notes
Always reference the [CMake Documentation](https://cmake.org/cmake/help/latest/) for explanation of features and cache variable usages/effects. Always reference the [CMake Documentation](https://cmake.org/cmake/help/latest/) and check CMake cache variables with `ccmake build` to discover all available options.
### Using your own Ghidra checkout ### Using your own Ghidra checkout
This method is useful for developing new features on top of the latest commits in Ghidra's default branch. If the commit(s) at the tip of Ghidra's default branch are not supported by this repo, we welcome pull requests to update support and pin that commit. This method helps develop new features on top of the latest commits in Ghidra's default branch. Please open an issue or pull request if the commit at the tip of Ghidra's default branch does not build.
**Arbitrary Ghidra checkouts are not officially supported.** **Arbitrary Ghidra checkouts/commits are not officially supported.**
If you want to use your own Ghidra source checkout, then set the following during CMake configuration: Set the following during CMake configuration if you want to use your own Ghidra source checkout:
* `-Dsleigh_GHIDRA_RELEASE_TYPE=HEAD` if using commits on Ghidra's default branch (`master`) or any branch that may be incompatible with the current stable version. * `-Dsleigh_RELEASE_TYPE=HEAD` if using commits on Ghidra's default branch (`master`) or any branch that may be incompatible with the current stable version.
* `-DFETCHCONTENT_SOURCE_DIR_GHIDRASOURCE=<path to your own Ghidra source>`. Remember, no existing [patches](../patches/HEAD) will be applied to your own source directory. * `-DFETCHCONTENT_SOURCE_DIR_GHIDRASOURCE=<path to your own Ghidra source>`. Remember, CMake will not apply any [patches](patches/HEAD) to the specified source directory.
```bash ```bash
git clone https://github.com/NationalSecurityAgency/ghidra src/ghidra git clone https://github.com/NationalSecurityAgency/ghidra src/ghidra
cmake -B build-dev-head -S . \ cmake -B build-dev-head -S . \
-Dsleigh_GHIDRA_RELEASE_TYPE=HEAD \ -Dsleigh_RELEASE_TYPE=HEAD \
-DFETCHCONTENT_SOURCE_DIR_GHIDRASOURCE="$(pwd)/src/ghidra" "-DFETCHCONTENT_SOURCE_DIR_GHIDRASOURCE=$PWD/src/ghidra"
``` ```
### Reusing Downloaded Ghidra Source ### Reusing Downloaded Ghidra Source
If you want to share a single Ghidra source checkout/clone for multiple build directories, the [_FetchContent Base Directory_](https://cmake.org/cmake/help/latest/module/FetchContent.html#variable:FETCHCONTENT_BASE_DIR) (`FETCHCONTENT_BASE_DIR`) should encode the build generator name and be located outside of the build directory (the name would look something like `cmake_fc_ghidra_${sleigh_GHIDRA_RELEASE_TYPE}_${CMAKE_GENERATOR}`). The following scenario is discouraged. It can be brittle if everything does not match up. It is only helpful if you do not want to apply Ghidra source patches yourself.
Initially, this means that every new build generator used for building the project will have to re-download the ghidra source tree, but any subsequent run with an already-initialize generator should be faster and skip the download. Suppose you want to share a single Ghidra source checkout/clone for multiple build directories. In that case, the _FetchContent Base Directory_ (`FETCHCONTENT_BASE_DIR`) should encode the build generator name and be located outside of the build directory (the name would look something like `cmake_fc_ghidra_${sleigh_RELEASE_TYPE}_${CMAKE_GENERATOR}`).
Initially, this means that every new build generator used for building the project will have to re-download the Ghidra source tree. Still, any subsequent run with an already-initialize generator should be faster and skip the download.
```bash ```bash
$ cmake -B build-release -S . -G Ninja \ $ cmake -B build-release -S . -G Ninja \
-DCMAKE_BUILD_TYPE=Release \ -DCMAKE_BUILD_TYPE=Release \
-DFETCHCONTENT_BASE_DIR=./src/cmake_fc_ghidra_stable_Ninja "-DFETCHCONTENT_BASE_DIR=$PWD/src/cmake_fc_ghidra_stable_Ninja"
-- Using Ghidra version 10.0.4 at commit 5b07797 -- Using Ghidra version 10.0.4 at commit 5b07797
-- Populating ghidrasource -- Populating ghidrasource
-- Configuring done -- Configuring done
@@ -69,7 +69,7 @@ HEAD is now at 5b07797cb Updated 10.0.4 Change History
$ cmake -B build-debug -S . -G Ninja \ $ cmake -B build-debug -S . -G Ninja \
-DCMAKE_BUILD_TYPE=Debug \ -DCMAKE_BUILD_TYPE=Debug \
-DFETCHCONTENT_BASE_DIR=./src/cmake_fc_ghidra_stable_Ninja "-DFETCHCONTENT_BASE_DIR=$PWD/src/cmake_fc_ghidra_stable_Ninja"
-- Using Ghidra version 10.0.4 at commit 5b07797 -- Using Ghidra version 10.0.4 at commit 5b07797
-- Populating ghidrasource -- Populating ghidrasource
-- Configuring done -- Configuring done
@@ -88,19 +88,19 @@ $ cmake -B build-debug -S . -G Ninja \
... ...
``` ```
The above also works when using `HEAD` commit of Ghidra. The above also works when using the `HEAD` commit of Ghidra.
```bash ```bash
$ cmake -B build-head-release -S . -G Ninja \ $ cmake -B build-head-release -S . -G Ninja \
-DCMAKE_BUILD_TYPE=Release \ -DCMAKE_BUILD_TYPE=Release \
-Dsleigh_GHIDRA_RELEASE_TYPE=HEAD \ -Dsleigh_RELEASE_TYPE=HEAD \
-DFETCHCONTENT_BASE_DIR=./src/cmake_fc_ghidra_HEAD_Ninja "-DFETCHCONTENT_BASE_DIR=$PWD/src/cmake_fc_ghidra_HEAD_Ninja"
... ...
$ cmake -B build-head-debug -S . -G Ninja \ $ cmake -B build-head-debug -S . -G Ninja \
-DCMAKE_BUILD_TYPE=Debug \ -DCMAKE_BUILD_TYPE=Debug \
-Dsleigh_GHIDRA_RELEASE_TYPE=HEAD \ -Dsleigh_RELEASE_TYPE=HEAD \
-DFETCHCONTENT_BASE_DIR=./src/cmake_fc_ghidra_HEAD_Ninja "-DFETCHCONTENT_BASE_DIR=$PWD/src/cmake_fc_ghidra_HEAD_Ninja"
... ...
``` ```
src/compile_options.cmake
+46
View File
@@ -0,0 +1,46 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
# Internal settings
option(sleigh_CPUI_RULECOMPILE "Allow user defined dynamic rules")
option(sleigh_CPUI_STATISTICS "Turn on collection of cover and cast statistics")
# Internal debug settings (naming is swapped to help with discoverability in CMake options)
option(sleigh_DEBUG_BLOCKCONSISTENT "Check that block graph structure is consistent")
option(sleigh_DEBUG_DFSVERIFY "Make sure that the block ordering algorithm produces a true depth first traversal of the dominator tree")
option(sleigh_DEBUG_MERGEMULTI "Check for MULTIEQUAL and INDIRECT intersections")
option(sleigh_DEBUG_OPACTION "Turns on all the action tracing facilities")
#
# Common options that can apply to all project targets
#
macro(sleigh_add_optional_defines target visibility)
set(opt_defines "")
if(sleigh_CPUI_RULECOMPILE)
list(APPEND opt_defines "CPUI_RULECOMPILE")
endif()
if(sleigh_CPUI_STATISTICS)
list(APPEND opt_defines "CPUI_STATISTICS")
endif()
if(sleigh_DEBUG_BLOCKCONSISTENT)
list(APPEND opt_defines "BLOCKCONSISTENT_DEBUG")
endif()
if(sleigh_DEBUG_DFSVERIFY)
list(APPEND opt_defines "DFSVERIFY_DEBUG")
endif()
if(sleigh_DEBUG_MERGEMULTI)
list(APPEND opt_defines "MERGEMULTI_DEBUG")
endif()
if(sleigh_DEBUG_OPACTION)
list(APPEND opt_defines "OPACTION_DEBUG")
endif()
if(WIN32)
list(APPEND opt_defines "_WINDOWS")
endif()
target_compile_definitions("${target}" ${visibility} ${opt_defines})
endmacro()
patches/HEAD/.gitkeep → src/patches/HEAD/.gitkeep
View File
patches/HEAD/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch → src/patches/HEAD/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch
View File
patches/HEAD/0002-Add-include-guards-to-decompiler-C-headers.patch → src/patches/HEAD/0002-Add-include-guards-to-decompiler-C-headers.patch
View File
patches/HEAD/0003-Fix-UBSAN-errors-in-decompiler.patch → src/patches/HEAD/0003-Fix-UBSAN-errors-in-decompiler.patch
View File
patches/HEAD/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch → src/patches/HEAD/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch
View File
patches/README.md → src/patches/README.md
View File
patches/stable/.gitkeep → src/patches/stable/.gitkeep
View File
patches/stable/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch → src/patches/stable/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch
View File
patches/stable/0002-Add-include-guards-to-decompiler-C-headers.patch → src/patches/stable/0002-Add-include-guards-to-decompiler-C-headers.patch
View File
patches/stable/0003-Fix-UBSAN-errors-in-decompiler.patch → src/patches/stable/0003-Fix-UBSAN-errors-in-decompiler.patch
View File
patches/stable/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch → src/patches/stable/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch
View File
src/setup-ghidra-source.cmake
+161 -10
View File
@@ -1,4 +1,13 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
# ---- Setup Ghidra Source code ---- # ---- Setup Ghidra Source code ----
include_guard(GLOBAL)
# Set up Ghidra repo human-readable version settings # Set up Ghidra repo human-readable version settings
set(sleigh_RELEASE_TYPE "stable" CACHE set(sleigh_RELEASE_TYPE "stable" CACHE
@@ -10,18 +19,23 @@ set_property(CACHE sleigh_RELEASE_TYPE PROPERTY STRINGS "stable" "HEAD")
# **** Setup pinned git info **** # **** Setup pinned git info ****
find_package(Git REQUIRED)
# Ghidra pinned stable version commit # Ghidra pinned stable version commit
set(ghidra_version "10.1.5") set(ghidra_version "10.1.5")
set(ghidra_git_tag "Ghidra_${ghidra_version}_build") set(ghidra_git_tag "Ghidra_${ghidra_version}_build")
set(ghidra_shallow TRUE) set(ghidra_shallow TRUE)
set(sleigh_ADDITIONAL_PATCHES "" CACHE STRING
"The accepted patch format is git patch files, to be applied via git am. The format of the list is a CMake semicolon separated list.")
# pinned stable patches list # pinned stable patches list
set(ghidra_patches set(ghidra_patches
PATCH_COMMAND git am --ignore-space-change --ignore-whitespace --no-gpg-sign PATCH_COMMAND "${GIT_EXECUTABLE}" am --ignore-space-change --ignore-whitespace --no-gpg-sign
"${CMAKE_CURRENT_SOURCE_DIR}/patches/stable/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/stable/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch"
"${CMAKE_CURRENT_SOURCE_DIR}/patches/stable/0002-Add-include-guards-to-decompiler-C-headers.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/stable/0002-Add-include-guards-to-decompiler-C-headers.patch"
"${CMAKE_CURRENT_SOURCE_DIR}/patches/stable/0003-Fix-UBSAN-errors-in-decompiler.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/stable/0003-Fix-UBSAN-errors-in-decompiler.patch"
"${CMAKE_CURRENT_SOURCE_DIR}/patches/stable/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/stable/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch"
) )
# Ghidra pinned commits used for pinning last known working HEAD commit # Ghidra pinned commits used for pinning last known working HEAD commit
@@ -34,11 +48,11 @@ if("${sleigh_RELEASE_TYPE}" STREQUAL "HEAD")
set(ghidra_git_tag "${ghidra_head_git_tag}") set(ghidra_git_tag "${ghidra_head_git_tag}")
set(ghidra_shallow FALSE) set(ghidra_shallow FALSE)
set(ghidra_patches set(ghidra_patches
PATCH_COMMAND git am --ignore-space-change --ignore-whitespace --no-gpg-sign PATCH_COMMAND "${GIT_EXECUTABLE}" am --ignore-space-change --ignore-whitespace --no-gpg-sign
"${CMAKE_CURRENT_SOURCE_DIR}/patches/HEAD/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/HEAD/0001-Small-improvements-to-C-decompiler-testing-from-CLI.patch"
"${CMAKE_CURRENT_SOURCE_DIR}/patches/HEAD/0002-Add-include-guards-to-decompiler-C-headers.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/HEAD/0002-Add-include-guards-to-decompiler-C-headers.patch"
"${CMAKE_CURRENT_SOURCE_DIR}/patches/HEAD/0003-Fix-UBSAN-errors-in-decompiler.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/HEAD/0003-Fix-UBSAN-errors-in-decompiler.patch"
"${CMAKE_CURRENT_SOURCE_DIR}/patches/HEAD/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch" "${CMAKE_CURRENT_LIST_DIR}/patches/HEAD/0004-Use-stroull-instead-of-stroul-to-parse-address-offse.patch"
) )
string(SUBSTRING "${ghidra_git_tag}" 0 7 ghidra_short_commit) string(SUBSTRING "${ghidra_git_tag}" 0 7 ghidra_short_commit)
else() else()
@@ -72,3 +86,140 @@ set(library_root "${ghidrasource_SOURCE_DIR}/Ghidra/Features/Decompiler/src/deco
if(NOT EXISTS "${library_root}/sleigh.hh") if(NOT EXISTS "${library_root}/sleigh.hh")
message(FATAL_ERROR "The Ghidra source directory has not been initialized correctly. Could not find '${library_root}'") message(FATAL_ERROR "The Ghidra source directory has not been initialized correctly. Could not find '${library_root}'")
endif() endif()
# Source collection variables
set(sleigh_core_source_list
"${library_root}/xml.cc"
"${library_root}/space.cc"
"${library_root}/float.cc"
"${library_root}/address.cc"
"${library_root}/pcoderaw.cc"
"${library_root}/translate.cc"
"${library_root}/opcodes.cc"
"${library_root}/globalcontext.cc"
)
if("${sleigh_RELEASE_TYPE}" STREQUAL "HEAD")
list(APPEND sleigh_core_source_list
"${library_root}/marshal.cc"
)
endif()
set(sleigh_deccore_source_list
"${library_root}/capability.cc"
"${library_root}/architecture.cc"
"${library_root}/options.cc"
"${library_root}/graph.cc"
"${library_root}/cover.cc"
"${library_root}/block.cc"
"${library_root}/cast.cc"
"${library_root}/typeop.cc"
"${library_root}/database.cc"
"${library_root}/cpool.cc"
"${library_root}/comment.cc"
"${library_root}/stringmanage.cc"
"${library_root}/fspec.cc"
"${library_root}/action.cc"
"${library_root}/loadimage.cc"
"${library_root}/grammar.cc"
"${library_root}/varnode.cc"
"${library_root}/op.cc"
"${library_root}/type.cc"
"${library_root}/variable.cc"
"${library_root}/varmap.cc"
"${library_root}/jumptable.cc"
"${library_root}/emulate.cc"
"${library_root}/emulateutil.cc"
"${library_root}/flow.cc"
"${library_root}/userop.cc"
"${library_root}/funcdata.cc"
"${library_root}/funcdata_block.cc"
"${library_root}/funcdata_op.cc"
"${library_root}/funcdata_varnode.cc"
"${library_root}/pcodeinject.cc"
"${library_root}/heritage.cc"
"${library_root}/prefersplit.cc"
"${library_root}/rangeutil.cc"
"${library_root}/ruleaction.cc"
"${library_root}/subflow.cc"
"${library_root}/blockaction.cc"
"${library_root}/merge.cc"
"${library_root}/double.cc"
"${library_root}/transform.cc"
"${library_root}/coreaction.cc"
"${library_root}/condexe.cc"
"${library_root}/override.cc"
"${library_root}/dynamic.cc"
"${library_root}/crc32.cc"
"${library_root}/prettyprint.cc"
"${library_root}/printlanguage.cc"
"${library_root}/printc.cc"
"${library_root}/printjava.cc"
"${library_root}/memstate.cc"
"${library_root}/opbehavior.cc"
"${library_root}/paramid.cc"
)
if("${sleigh_RELEASE_TYPE}" STREQUAL "HEAD")
list(APPEND sleigh_deccore_source_list
"${library_root}/unionresolve.cc"
)
endif()
set(sleigh_extra_source_list
"${library_root}/callgraph.cc"
"${library_root}/ifacedecomp.cc"
"${library_root}/ifaceterm.cc"
"${library_root}/inject_sleigh.cc"
"${library_root}/interface.cc"
"${library_root}/libdecomp.cc"
"${library_root}/loadimage_xml.cc"
"${library_root}/raw_arch.cc"
"${library_root}/rulecompile.cc"
"${library_root}/sleigh_arch.cc"
"${library_root}/testfunction.cc"
"${library_root}/unify.cc"
"${library_root}/xml_arch.cc"
)
set(sleigh_source_list
"${library_root}/sleigh.cc"
"${library_root}/pcodeparse.cc"
"${library_root}/pcodecompile.cc"
"${library_root}/sleighbase.cc"
"${library_root}/slghsymbol.cc"
"${library_root}/slghpatexpress.cc"
"${library_root}/slghpattern.cc"
"${library_root}/semantics.cc"
"${library_root}/context.cc"
"${library_root}/filemanage.cc"
)
set(sleigh_ghidra_source_list
"${library_root}/ghidra_arch.cc"
"${library_root}/inject_ghidra.cc"
"${library_root}/ghidra_translate.cc"
"${library_root}/loadimage_ghidra.cc"
"${library_root}/typegrp_ghidra.cc"
"${library_root}/database_ghidra.cc"
"${library_root}/ghidra_context.cc"
"${library_root}/cpool_ghidra.cc"
"${library_root}/ghidra_process.cc"
"${library_root}/comment_ghidra.cc"
"${library_root}/string_ghidra.cc"
)
set(sleigh_slacomp_source_list
"${library_root}/slgh_compile.cc"
"${library_root}/slghparse.cc"
"${library_root}/slghscan.cc"
)
# Include separate file to make it easier to find user-specified compile
# options
include("${CMAKE_CURRENT_LIST_DIR}/compile_options.cmake")
# Sets 'spec_file_list' variable
if(sleigh_RELEASE_IS_HEAD)
include("${CMAKE_CURRENT_LIST_DIR}/spec_files_HEAD.cmake")
else()
include("${CMAKE_CURRENT_LIST_DIR}/spec_files_stable.cmake")
endif()
spec-files-list/spec_files_HEAD.cmake → src/spec_files_HEAD.cmake
+8
View File
@@ -1,3 +1,11 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
set(spec_file_list set(spec_file_list
"${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/6502.slaspec" "${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/6502.slaspec"
"${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/65c02.slaspec" "${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/65c02.slaspec"
spec-files-list/spec_files_stable.cmake → src/spec_files_stable.cmake
+8
View File
@@ -1,3 +1,11 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
set(spec_file_list set(spec_file_list
"${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/6502.slaspec" "${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/6502.slaspec"
"${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/65c02.slaspec" "${ghidrasource_SOURCE_DIR}/Ghidra/Processors/6502/data/languages/65c02.slaspec"
support/CMakeLists.txt
+54 -15
View File
@@ -9,7 +9,7 @@
# Generate the build and install directories to use in the support helpers # Generate the build and install directories to use in the support helpers
configure_file( configure_file(
"${CMAKE_CURRENT_LIST_DIR}/SpecFilePaths.h.in" "${CMAKE_CURRENT_LIST_DIR}/SpecFilePaths.h.in"
"${CMAKE_CURRENT_BINARY_DIR}/SpecFilePaths.h" "${CMAKE_CURRENT_BINARY_DIR}/include/sleigh/SpecFilePaths.h"
@ONLY @ONLY
) )
@@ -25,7 +25,7 @@ set(POST_CONFIGURE_FILE "${CMAKE_CURRENT_BINARY_DIR}/Version.cpp")
set(GIT_STATE_FILE "${CMAKE_CURRENT_BINARY_DIR}/git-state-sleigh") set(GIT_STATE_FILE "${CMAKE_CURRENT_BINARY_DIR}/git-state-sleigh")
set(GIT_WORKING_DIR "${PROJECT_SOURCE_DIR}") set(GIT_WORKING_DIR "${PROJECT_SOURCE_DIR}")
set(GIT_FAIL_IF_NONZERO_EXIT OFF) set(GIT_FAIL_IF_NONZERO_EXIT OFF)
include("${PROJECT_SOURCE_DIR}/cmake/git_watcher.cmake") include("../cmake/git_watcher.cmake")
# Generate GHIDRA version helpers # Generate GHIDRA version helpers
configure_file( configure_file(
@@ -34,26 +34,65 @@ configure_file(
@ONLY @ONLY
) )
add_library(support add_library(sleigh_support
Support.cpp Support.cpp
"${POST_CONFIGURE_FILE}" "${POST_CONFIGURE_FILE}"
"${CMAKE_CURRENT_BINARY_DIR}/GhidraVersion.cpp" "${CMAKE_CURRENT_BINARY_DIR}/GhidraVersion.cpp"
) )
add_library(sleigh::support ALIAS sleigh_support)
# Need to explicitly add this dependency because BYPRODUCTS doesn't work under # Need to explicitly add this dependency because BYPRODUCTS doesn't work under
# CMake 3.16 with GNU Makefiles # CMake 3.16 with GNU Makefiles
add_dependencies(support check_git) add_dependencies(sleigh_support check_git)
add_library(sleigh::support ALIAS support) target_compile_features(sleigh_support PUBLIC cxx_std_17)
set_target_properties(sleigh_support PROPERTIES
target_compile_features(support PUBLIC EXPORT_NAME support
cxx_std_17 OUTPUT_NAME slaSupport
)
target_include_directories(sleigh_support
${warning_guard}
PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
)
target_include_directories(sleigh_support
SYSTEM
PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>"
) )
set_target_properties(support PROPERTIES if(NOT CMAKE_SKIP_INSTALL_RULES)
INTERFACE_POSITION_INDEPENDENT_CODE ON if(PROJECT_IS_TOP_LEVEL)
) set(CMAKE_INSTALL_INCLUDEDIR include/sleigh CACHE PATH "")
endif()
target_include_directories(support PRIVATE include(GNUInstallDirs)
"$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>"
"$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/support>" install(
) TARGETS sleigh_support
EXPORT sleighSupportTargets
RUNTIME #
COMPONENT sleigh_SupportRuntime
LIBRARY #
COMPONENT sleigh_SupportRuntime
NAMELINK_COMPONENT sleigh_SupportDevelopment
ARCHIVE #
COMPONENT sleigh_SupportDevelopment
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
)
install(
DIRECTORY
include/
"${CMAKE_CURRENT_BINARY_DIR}/include/"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
COMPONENT sleigh_SupportDevelopment
)
install(
EXPORT sleighSupportTargets
DESTINATION "${sleigh_INSTALL_CMAKEDIR}"
NAMESPACE sleigh::
COMPONENT sleigh_SupportDevelopment
)
endif()
support/GhidraVersion.cpp.in
+2 -2
View File
@@ -6,7 +6,7 @@
the LICENSE file found in the root directory of this source tree. the LICENSE file found in the root directory of this source tree.
*/ */
#include "Version.h" #include "sleigh/Version.h"
namespace sleigh { namespace sleigh {
@@ -15,7 +15,7 @@ std::string_view GetGhidraVersion(void) { return "@ghidra_version@"; }
std::string_view GetGhidraCommitHash(void) { return "@ghidra_git_tag@"; } std::string_view GetGhidraCommitHash(void) { return "@ghidra_git_tag@"; }
std::string_view GetGhidraReleaseType(void) { std::string_view GetGhidraReleaseType(void) {
return "@sleigh_GHIDRA_RELEASE_TYPE@"; return "@sleigh_RELEASE_TYPE@";
} }
} // namespace sleigh } // namespace sleigh
support/SpecFilePaths.h.in
+2 -2
View File
@@ -10,7 +10,7 @@
namespace sleigh { namespace sleigh {
static const char *kSleighSpecInstallDir = "@sleigh_SPEC_INSTALL_DIR@"; static const char *kSleighSpecInstallDir = "@sleigh_INSTALL_SPECDIR@";
static const char *kSleighSpecBuildDir = "@sleigh_SPEC_BUILD_DIR@"; static const char *kSleighSpecBuildDir = "@spec_files_build_dir@";
} // namespace sleigh } // namespace sleigh
support/Support.cpp
+3 -3
View File
@@ -6,9 +6,9 @@
the LICENSE file found in the root directory of this source tree. the LICENSE file found in the root directory of this source tree.
*/ */
#include "SpecFilePaths.h" #include "sleigh/Support.h"
#include "Support.h" #include "sleigh/SpecFilePaths.h"
namespace sleigh { namespace sleigh {
@@ -18,7 +18,7 @@ std::optional<std::filesystem::path>
FindSpecFileInSearchPath(std::string_view file_name, FindSpecFileInSearchPath(std::string_view file_name,
std::filesystem::path search_path) { std::filesystem::path search_path) {
search_path.append("Ghidra").append("Processors"); search_path.append("Ghidra").append("Processors");
// Check whether a SLEIGH installation exists at this path // Check whether a Sleigh installation exists at this path
if (!std::filesystem::is_directory(search_path)) { if (!std::filesystem::is_directory(search_path)) {
return {}; return {};
} }
support/Version.cpp.in
+1 -1
View File
@@ -31,7 +31,7 @@
SOFTWARE. SOFTWARE.
*/ */
#include "Version.h" #include "sleigh/Version.h"
namespace sleigh { namespace sleigh {
support/Support.h → support/include/sleigh/Support.h
View File
support/Version.h → support/include/sleigh/Version.h
View File
include/libsleigh.hh → support/include/sleigh/libsleigh.hh
View File
tests/CMakeLists.txt
+47
View File
@@ -0,0 +1,47 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
#
# Tests from ghidra repo
#
add_executable(sleigh_ghidra_test
${sleigh_core_source_list}
${sleigh_deccore_source_list}
${sleigh_source_list}
${sleigh_extra_source_list}
"${library_root}/test.cc"
"${library_root}/../unittests/testcirclerange.cc"
"${library_root}/../unittests/testfloatemu.cc"
"${library_root}/../unittests/testtypes.cc"
)
target_compile_features(sleigh_ghidra_test PRIVATE cxx_std_11)
target_include_directories(sleigh_ghidra_test PRIVATE "${library_root}")
include(CheckIncludeFileCXX)
check_include_file_cxx(termios.h HAVE_TERMIOS_H)
if(HAVE_TERMIOS_H)
target_compile_definitions(sleigh_ghidra_test PRIVATE
__TERMINAL__
)
endif()
sleigh_add_optional_defines(sleigh_ghidra_test PRIVATE)
add_test(
NAME sleigh_ghidra_unittest
COMMAND sleigh_ghidra_test -sleighpath "${PROJECT_BINARY_DIR}" unittests
)
add_test(
NAME sleigh_ghidra_datatest
COMMAND sleigh_ghidra_test -sleighpath "${PROJECT_BINARY_DIR}"
-path "${library_root}/../datatests"
datatests
)
tests/find_package/CMakeLists.txt
+2 -2
View File
@@ -6,10 +6,10 @@
# the LICENSE file found in the root directory of this source tree. # the LICENSE file found in the root directory of this source tree.
# #
cmake_minimum_required(VERSION 3.15.0) cmake_minimum_required(VERSION 3.18)
project("sleigh_find_package_test") project("sleigh_find_package_test")
find_package(sleigh REQUIRED) find_package(sleigh REQUIRED COMPONENTS Support)
add_executable(sleigh_test add_executable(sleigh_test
src/main.cpp src/main.cpp
tools/CMakeLists.txt
+28 -2
View File
@@ -1,9 +1,35 @@
# #
# Copyright (c) 2021-present, Trail of Bits, Inc. # Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved. # All rights reserved.
# #
# This source code is licensed in accordance with the terms specified in # This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree. # the LICENSE file found in the root directory of this source tree.
# #
add_subdirectory(sleigh-lift) cmake_minimum_required(VERSION 3.18)
include(../cmake/prelude.cmake)
include(../src/setup-ghidra-source.cmake)
project(sleigh_tools
VERSION "${ghidra_version}"
DESCRIPTION "Sleigh tools"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
LANGUAGES CXX
)
option(sleigh_BUILD_SPECCOMPILER "Build the sleigh spec compiler executable (\"sleigh\")" ON)
option(sleigh_BUILD_DECOMPILER "Build the decompiler executable (\"decomp\")" ON)
option(sleigh_BUILD_GHIDRA "Build the Ghidra executable (\"ghidra\")" ON)
if(sleigh_BUILD_SPECCOMPILER)
add_subdirectory(spec-compiler)
endif()
if(sleigh_BUILD_DECOMPILER)
add_subdirectory(decompiler)
endif()
if(sleigh_BUILD_GHIDRA)
add_subdirectory(ghidra)
endif()
tools/decompiler/CMakeLists.txt
+65
View File
@@ -0,0 +1,65 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
cmake_minimum_required(VERSION 3.18)
include(../../cmake/prelude.cmake)
include(../../src/setup-ghidra-source.cmake)
project(sleigh_decompiler
VERSION "${ghidra_version}"
DESCRIPTION "Sleigh decompiler"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
LANGUAGES CXX
)
include(../../cmake/project-is-top-level.cmake)
add_executable(sleigh_decompiler
${sleigh_core_source_list}
${sleigh_deccore_source_list}
${sleigh_extra_source_list}
${sleigh_source_list}
"${library_root}/consolemain.cc"
)
add_executable(sleigh::decompiler ALIAS sleigh_decompiler)
target_compile_features(sleigh_decompiler PUBLIC cxx_std_11)
target_include_directories(sleigh_decompiler PRIVATE "$<BUILD_INTERFACE:${library_root}>")
include(CheckIncludeFileCXX)
check_include_file_cxx(termios.h HAVE_TERMIOS_H)
if(HAVE_TERMIOS_H)
target_compile_definitions(sleigh_decompiler PRIVATE
__TERMINAL__
)
endif()
target_compile_definitions(sleigh_decompiler PRIVATE
$<$<CONFIG:Debug>:CPUI_DEBUG>
)
sleigh_add_optional_defines(sleigh_decompiler PRIVATE)
set_target_properties(sleigh_decompiler PROPERTIES
EXPORT_NAME decompiler
OUTPUT_NAME decomp
OUTPUT_NAME_DEBUG decomp_dbg
)
if(NOT CMAKE_SKIP_INSTALL_RULES)
include("GNUInstallDirs")
install(
TARGETS sleigh_decompiler
EXPORT sleighTargets
RUNTIME COMPONENT sleigh_Runtime
)
if(PROJECT_IS_TOP_LEVEL)
include(CPack)
endif()
endif()
tools/ghidra/CMakeLists.txt
+61
View File
@@ -0,0 +1,61 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
cmake_minimum_required(VERSION 3.18)
include(../../cmake/prelude.cmake)
include(../../src/setup-ghidra-source.cmake)
project(sleigh_ghidra
VERSION "${ghidra_version}"
DESCRIPTION "Sleigh ghidra service"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
LANGUAGES CXX
)
include(../../cmake/project-is-top-level.cmake)
add_executable(sleigh_ghidra
${sleigh_core_source_list}
${sleigh_deccore_source_list}
${sleigh_ghidra_source_list}
"$<$<CONFIG:Debug>:${library_root}/callgraph.cc>"
"$<$<CONFIG:Debug>:${library_root}/ifacedecomp.cc>"
"$<$<CONFIG:Debug>:${library_root}/ifaceterm.cc>"
"$<$<CONFIG:Debug>:${library_root}/interface.cc>"
"$<$<CONFIG:Debug>:${library_root}/testfunction.cc>"
)
add_executable(sleigh::ghidra ALIAS sleigh_ghidra)
target_compile_features(sleigh_ghidra PUBLIC cxx_std_11)
target_include_directories(sleigh_ghidra PRIVATE "$<BUILD_INTERFACE:${library_root}>")
target_compile_definitions(sleigh_ghidra PRIVATE
$<$<CONFIG:Debug>:CPUI_DEBUG>
)
sleigh_add_optional_defines(sleigh_ghidra PRIVATE)
set_target_properties(sleigh_ghidra PROPERTIES
EXPORT_NAME ghidra
OUTPUT_NAME ghidra
OUTPUT_NAME_DEBUG ghidra_dbg
)
if(NOT CMAKE_SKIP_INSTALL_RULES)
include("GNUInstallDirs")
install(
TARGETS sleigh_ghidra
EXPORT sleighTargets
RUNTIME COMPONENT sleigh_Runtime
)
if(PROJECT_IS_TOP_LEVEL)
include(CPack)
endif()
endif()
tools/sleigh-lift/CMakeLists.txt
-36
View File
@@ -1,36 +0,0 @@
#
# Copyright (c) 2021-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
add_executable(sleigh-lift
src/main.cpp
)
add_executable(sleigh::sleigh-lift ALIAS sleigh-lift)
target_link_libraries(sleigh-lift PRIVATE
sleigh::sla
sleigh::decomp
sleigh::support
)
if(NOT CMAKE_SKIP_INSTALL_RULES)
install(
TARGETS
sleigh-lift
EXPORT
"sleigh"
DESTINATION
"${CMAKE_INSTALL_BINDIR}"
PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE
)
endif()
tools/spec-compiler/CMakeLists.txt
+51
View File
@@ -0,0 +1,51 @@
#
# Copyright (c) 2022-present, Trail of Bits, Inc.
# All rights reserved.
#
# This source code is licensed in accordance with the terms specified in
# the LICENSE file found in the root directory of this source tree.
#
cmake_minimum_required(VERSION 3.18)
include(../../cmake/prelude.cmake)
include(../../src/setup-ghidra-source.cmake)
project(sleigh_sleigh
VERSION "${ghidra_version}"
DESCRIPTION "Sleigh spec compiler"
HOMEPAGE_URL "https://github.com/lifting-bits/sleigh"
LANGUAGES CXX
)
include(../../cmake/project-is-top-level.cmake)
add_executable(sleigh_sleigh
${sleigh_core_source_list}
${sleigh_source_list}
${sleigh_slacomp_source_list}
)
add_executable(sleigh::sleigh ALIAS sleigh_sleigh)
target_compile_features(sleigh_sleigh PUBLIC cxx_std_11)
target_include_directories(sleigh_sleigh PRIVATE "$<BUILD_INTERFACE:${library_root}>")
sleigh_add_optional_defines(sleigh_sleigh PRIVATE)
set_target_properties(sleigh_sleigh PROPERTIES
EXPORT_NAME sleigh
OUTPUT_NAME sleigh
OUTPUT_NAME_DEBUG sleigh_dbg
)
if(NOT CMAKE_SKIP_INSTALL_RULES)
include("GNUInstallDirs")
install(
TARGETS sleigh_sleigh
EXPORT sleighTargets
RUNTIME COMPONENT sleigh_Runtime
)
if(PROJECT_IS_TOP_LEVEL)
include(CPack)
endif()
endif()