I’m having trouble integrating the GMP library into my CMake project. Specifically, I’m struggling to configure CMake to automatically download and include GMP using FetchContent_Declare. I’m unsure about the necessary CMake configurations and whether additional steps like compilation or building are required for GMP.

To learn I am making a cryptography library in C++. Recently I implemented ECC/ECDSA using a small multi-precision library called InfInt. Which worked to make sure my logic worked, but it is quite slow. Using a profiler Tracy I found the bottleneck was the division arithmetic in InfInt, so I am trying to replace InfInt with GMP.

I have used GMP in the past by building it with MSYS2 and linking to it in my other projects. But since this library is open-source and I would hate if people download my library and can’t just use it out of the box, I want to use CMake to seamlessly compile and link GMP.

But when I try to use CMake’s FetchContent_Declare in a similar way I have used it for another library called googletest I get this error:

...
[build] LINK : fatal error LNK1104: cannot open file 'gmp.lib' [C:ProjectsCryptoLibrarybuildteststests.vcxproj]
[proc] The command: "C:Program FilesCMakebincmake.EXE" --build c:/Projects/CryptoLibrary/build --config Debug --target ALL_BUILD -j 14 -- exited with code: 1
[driver] Build completed: 00:00:07.522
[build] Build finished with exit code 1

I suspect the problem is that I am not properly telling CMake what the GMP library is, so it cannot compile the gmp.lib file like I was able to for google test and infint. But this is where I am clueless on where to continue to try to solve this if this even is the problem.

Project overview:

To develop my library I am using Visual Studio Code, I have been compiling my project using C++11 MSVC, but I am not partial to these, this is just what has worked so far. As I mentioned above I am using CMake’s FetchContent_Declare to retrieve googletest, but I followed a tutorial for.

Simple file system

CryptoLibrary/
│
├── CMakeLists.txt
├── src/
│   ├── ecc/
│   │   ├── ecc.cpp
│   │   ├── ecc.h
│   │   ├── standardCurves.h
│   │   └── ecdsa/
│   │       └── ecdsa.cpp
│   └── ...
│
├── include/
│   ├── CryptoLibrary/
│   │   ├── ecdsa.h
│   │   └── ...
│   └── ...
│
├── tests/
│   ├── CMakeLists.txt
│   ├── eccTests.cpp
│   ├── ecdsaTests.cpp
│   └── ...
│
├── external/
│   └── infint/
│       ├── CMakeLists.txt
│       ├── infint.h
│       └── main.cpp
│
├── build/
│   └── ...
│ 
└── .vscode/
    └── ...

Here is also a simplified version of my Root CMakeLists.txt:

cmake_minimum_required(VERSION 3.16.3)

set (CMAKE_C_STANDARD 99)
set (CMAKE_CXX_STANDARD 20)
set (CMAKE_POSITION_INDEPENDENT_CODE ON)

set (Project_Name CryptographyLibrary)
project (${Project_Name} VERSION 0.3.1 LANGUAGES C CXX)

set(FETCHCONTENT_BASE_DIR "${CMAKE_BINARY_DIR}/external")
set(FETCHCONTENT_UPDATES_DISCONNECTED ON)

enable_testing ()

include(FetchContent)

FetchContent_Declare(
    googletest
    URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
)

FetchContent_Declare(
  gmp
  URL https://gmplib.org/download/gmp/gmp-6.3.0.tar.lz
)

set (Sources
    src/ecc/ecc.cpp
    src/ecc/ecdsa/ecdsa.cpp
    #...
)

set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)
FetchContent_MakeAvailable(gmp)

add_library (${Project_Name} STATIC ${Sources})
# Specify the directories where header files are located
target_include_directories(${Project_Name} PUBLIC ${PROJECT_SOURCE_DIR}/include)
target_include_directories(${Project_Name} PRIVATE ${PROJECT_SOURCE_DIR}/external)
target_include_directories(${Project_Name} PRIVATE ${PROJECT_SOURCE_DIR}/tools)

add_subdirectory(external/infint)

target_link_libraries(${Project_Name} PRIVATE gtest_main)
target_link_libraries(${Project_Name} PRIVATE gmp)

add_subdirectory(tests)

And here are the two CMakeLists.txt inside my tests/ and external/infint/ directories:
tests/CMakeLists.txt

cmake_minimum_required(VERSION 3.16.3)

include(GoogleTest)

set (This tests)

set (Sources
    eccTests.cpp
    ecdsaTests.cpp
    ...
)

add_executable (${This} ${Sources})

target_link_libraries (${This} PRIVATE
    GTest::gtest_main
    CryptographyLibrary
)

add_test (
    NAME ${This}
    COMMAND ${This}
)

include(GoogleTest)
gtest_discover_tests(${This})

external/infint/CMakeLists.txt

set (This infint)
add_library(${This} STATIC main.cpp)
target_link_libraries (${This} PRIVATE CryptographyLibrary)
target_include_directories(${This} PUBLIC ${PROJECT_SOURCE_DIR})

You may have noticed I am not using FetchContent_Declare to get InfInt. This is because it is a small two file library, and never planned to use it when I merge to main. So I just bundled it and add the executable to my project using CMake. This is not something that I believe would be a good solution to also include GMP.

I included what I thought would be useful for context here, but let me know if there are any other parts that would be useful to see to help me solve this.

What I tried

Using FetchContent_Declare in root CMakeLists.txt

This is the approach that is shown in the project overview above. I initially attempted to use CMake’s FetchContent_Declare to fetch and include the GMP library directly into my project. This approach involved specifying the GMP library URL and adding it as a dependency in my root CMakeLists.txt file.

Manual Installation of GMP

As an alternative, I considered manually bundleing a trimmed version of the GMP library in the library and then linking it to our project. But I quickly found out how large the GMP library is, so it would add a lot of code to my library.

Using ExternalProject_Add in root CMakeLists.txt

Another approach I considered was using CMake’s ExternalProject_Add to download, build, and install the GMP library as an external project during the build process of our library. This approach I didn’t dig to much into because it seemed similar to FetchContenct_Declare, and I prefered using FetchContent_Declare. But if I am missing something that would make this approach better I am not dismissing it.

Using CMake’s find_package

I followed this stackoverflow question, but as someone would need to install GMP on their computer and follow the configuration to compile GMP themselves this is not an ideal solution.

Ideal outcome

The most ideal outcome would be a seamless integration of GMP into the project via CMake, where developers can simply include the library without needing to manually download, configure, or link against GMP, streamlining the development process and reducing potential errors or compatibility issues.

How I envision others using the library, and how I have used the library in demonstrations is also using CMakes FetchContent_Declare for my library from GitHub. Once they do that then they can just do #include <CryptographyLibrary/*.h> and it just works.

A few observations

Just something I noticed while looking at the actual repo of the GMP library that I downloaded to my computer. I could not find the gmp.h file in the repo, but I could only find the gmpxx.h file.

Other considerations

I am not dead set on only using GMP, or only solving this problem with FetchContent_Declare from CMake. But I am dead set on using CMake. So if you know another optimized Multi-precision library that I could use for the purpose of cryptography (which has its own special security considerations) then I am very open to looking into those!

I have also attempted to use another library ctbignum but had problems switching my build system to use C++20 gcc which seems required for ctbignum and would limit where and how my library can be used.