Help compiling mpack with mingw32

[Josef-Joubert]

Good day all, I have a rather compilcated project which compiles a static C library, and then a shared C++ library and links them. This project is also cross platform, so I am compiling with gcc/g++, but now I'm adding compilation with mingw32.

I've been using this mpack project for a while now with GNU compiler and it works great! But now that I'm trying to cross compile for Windows with mingw32 I'm running into problems.

I created a minimum example which shows the problem.

C file ( compiles to static library) :

#include "mpack.h"

void func() {
    mpack_write_int( NULL, 0 );
}

C++ file ( compiles to shared library ):

#include "mpack.h"

void func2() {
    mpack_write_int( NULL, 0 );
}

Compilation script:

#!/bin/bash

compile() {
    # Compile C file to object file
    echo "Compiling C file..."
    ${PREFIX}gcc -c "$C_SOURCE" -o "${C_SOURCE%.c}.o"
    ${PREFIX}gcc -c mpack.c -o "mpack.o"

    # Create static library
    echo "Creating static library..."
    ${PREFIX}ar -rcs "lib${LIB_NAME}.a" "${C_SOURCE%.c}.o" "mpack.o"

    # Compile C++ file to shared library
    echo "Creating shared library..."
    ${PREFIX}g++ -shared -o "lib${LIB_NAME}.so" \
        "${CPP_SOURCE}" \
        "-L." \
        "-l${LIB_NAME}" \
        -fPIC

    echo "Build complete!"
}

echo "------------------------------------------------------------------------"
echo "Compiling GCC"
echo "------------------------------------------------------------------------"

C_SOURCE=c_file.c
CPP_SOURCE=cpp_file.cpp
LIB_NAME=out.so
PREFIX=

compile

echo "------------------------------------------------------------------------"
echo "Compiling MinGW"
echo "------------------------------------------------------------------------"

C_SOURCE=c_file.c
CPP_SOURCE=cpp_file.cpp
LIB_NAME=out.dll
PREFIX=x86_64-w64-mingw32-

compile

I get output:

------------------------------------------------------------------------
Compiling GCC
------------------------------------------------------------------------
Compiling C file...
Creating static library...
Creating shared library...
Build complete!
------------------------------------------------------------------------
Compiling MinGW
------------------------------------------------------------------------
Compiling C file...
Creating static library...
Creating shared library...
/usr/bin/x86_64-w64-mingw32-ld: ./libout.dll.a(mpack.o):mpack.c:(.text+0xbaa): multiple definition of `mpack_write_int'; /tmp/cciDd3uY.o:cpp_file.cpp:(.text$mpack_write_int[mpack_write_int]+0x0): first defined here
collect2: error: ld returned 1 exit status
Build complete!

So the same compilation that works for GCC does not work for MinGW. The problem(s) seem to be with these inline functions in mpack.h:

/** Writes an integer in the most efficient packing available. */
MPACK_INLINE void mpack_write_int(mpack_writer_t* writer, int64_t value) {
    mpack_write_i64(writer, value);
}

Any use of any of these header inlined functions will cause linking issues on MinGW.

Does anyone know how I can compile this without changing the mpack.h/.c ?

x86_64-w64-mingw32-gcc --version
x86_64-w64-mingw32-gcc (GCC) 13-win32
Copyright (C) 2023 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

[JoriOtega]

#!/bin/bash

# Create test C file
echo "Creating test C file..."
cat > test_c_file.c << 'EOF'
#include "mpack.h"

void c_function() {
    mpack_writer_t writer;
    char buffer[1024];
    mpack_writer_init(&writer, buffer, sizeof(buffer));
    // Use mpack_write_i64 directly instead of mpack_write_int to avoid inline issues
    mpack_write_i64(&writer, 42);
    mpack_writer_destroy(&writer);
}
EOF

# Create test C++ file
echo "Creating test C++ file..."
cat > test_cpp_file.cpp << 'EOF'
#include "mpack.h"
#include <iostream>

extern "C" void c_function();

void cpp_function() {
    mpack_writer_t writer;
    char buffer[1024];
    mpack_writer_init(&writer, buffer, sizeof(buffer));
    // Use mpack_write_i64 directly instead of mpack_write_int to avoid inline issues
    mpack_write_i64(&writer, 100);
    mpack_writer_destroy(&writer);
    std::cout << "C++ function called" << std::endl;
}

int main() {
    c_function();
    cpp_function();
    std::cout << "Mixed C/C++ project works!" << std::endl;
    return 0;
}
EOF

# Function to compile mpack library
compile() {
    # Set library name
    if [ -z "$LIB_NAME" ]; then
        LIB_NAME=mpack
    fi
    
    echo "Compiling mpack source files..."
    echo "Using prefix: $PREFIX"
    echo "Library name will be: lib${LIB_NAME}.a"
    
    # Compile all mpack C files to object files with MinGW fix
    if [ "$PREFIX" = "x86_64-w64-mingw32-" ]; then
        echo "Using MinGW with gnu89-inline for compatibility..."
        ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c mpack-common.c -o mpack-common.o || { echo "Failed to compile mpack-common.c"; return 1; }
        ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c mpack-expect.c -o mpack-expect.o || { echo "Failed to compile mpack-expect.c"; return 1; }
        ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c mpack-node.c -o mpack-node.o || { echo "Failed to compile mpack-node.c"; return 1; }
        ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c mpack-platform.c -o mpack-platform.o || { echo "Failed to compile mpack-platform.c"; return 1; }
        ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c mpack-reader.c -o mpack-reader.o || { echo "Failed to compile mpack-reader.c"; return 1; }
        ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c mpack-writer.c -o mpack-writer.o || { echo "Failed to compile mpack-writer.c"; return 1; }
    else
        ${PREFIX}gcc -fPIC -c mpack-common.c -o mpack-common.o || { echo "Failed to compile mpack-common.c"; return 1; }
        ${PREFIX}gcc -fPIC -c mpack-expect.c -o mpack-expect.o || { echo "Failed to compile mpack-expect.c"; return 1; }
        ${PREFIX}gcc -fPIC -c mpack-node.c -o mpack-node.o || { echo "Failed to compile mpack-node.c"; return 1; }
        ${PREFIX}gcc -fPIC -c mpack-platform.c -o mpack-platform.o || { echo "Failed to compile mpack-platform.c"; return 1; }
        ${PREFIX}gcc -fPIC -c mpack-reader.c -o mpack-reader.o || { echo "Failed to compile mpack-reader.c"; return 1; }
        ${PREFIX}gcc -fPIC -c mpack-writer.c -o mpack-writer.o || { echo "Failed to compile mpack-writer.c"; return 1; }
    fi

    # Create static library
    echo "Creating static library: lib${LIB_NAME}.a"
    ${PREFIX}ar -rcs lib${LIB_NAME}.a mpack-common.o mpack-expect.o mpack-node.o mpack-platform.o mpack-reader.o mpack-writer.o || { echo "Failed to create static library"; return 1; }

    # Create dynamic library
    echo "Creating dynamic library: lib${LIB_NAME}${SHARED_EXT}"
    if [ "$PREFIX" = "x86_64-w64-mingw32-" ]; then
        ${PREFIX}gcc -shared -o lib${LIB_NAME}${SHARED_EXT} mpack-common.o mpack-expect.o mpack-node.o mpack-platform.o mpack-reader.o mpack-writer.o || { echo "Failed to create dynamic library"; return 1; }
    else
        ${PREFIX}gcc -shared -fPIC -o lib${LIB_NAME}${SHARED_EXT} mpack-common.o mpack-expect.o mpack-node.o mpack-platform.o mpack-reader.o mpack-writer.o || { echo "Failed to create dynamic library"; return 1; }
    fi

    # Test mixed C/C++ compilation
    if [ "$TEST_MIXED" = "1" ]; then
        echo "Testing mixed C/C++ compilation..."
        
        # Compile C file to object with MinGW fix if needed
        echo "Compiling C test file..."
        if [ "$PREFIX" = "x86_64-w64-mingw32-" ]; then
            ${PREFIX}gcc -std=c99 -fgnu89-inline -fPIC -c test_c_file.c -o test_c_file.o || { echo "Failed to compile C test file"; return 1; }
        else
            ${PREFIX}gcc -fPIC -c test_c_file.c -o test_c_file.o || { echo "Failed to compile C test file"; return 1; }
        fi
        
        # Create static library with C object
        echo "Creating static library with C code..."
        ${PREFIX}ar -rcs lib${LIB_NAME}_mixed.a mpack-common.o mpack-expect.o mpack-node.o mpack-platform.o mpack-reader.o mpack-writer.o test_c_file.o || { echo "Failed to create mixed library"; return 1; }
        
        # Create dynamic library with C object
        echo "Creating dynamic library with C code..."
        if [ "$PREFIX" = "x86_64-w64-mingw32-" ]; then
            ${PREFIX}gcc -shared -o lib${LIB_NAME}_mixed${SHARED_EXT} mpack-common.o mpack-expect.o mpack-node.o mpack-platform.o mpack-reader.o mpack-writer.o test_c_file.o || { echo "Failed to create mixed dynamic library"; return 1; }
        else
            ${PREFIX}gcc -shared -fPIC -o lib${LIB_NAME}_mixed${SHARED_EXT} mpack-common.o mpack-expect.o mpack-node.o mpack-platform.o mpack-reader.o mpack-writer.o test_c_file.o || { echo "Failed to create mixed dynamic library"; return 1; }
        fi
        
        
        # Test both static and dynamic linking
        echo "Testing static linking..."
        if [ "$PREFIX" = "x86_64-w64-mingw32-" ]; then
            ${PREFIX}g++ -std=c++11 test_cpp_file.cpp -L. -l${LIB_NAME}_mixed -o mixed_test_static${EXE_EXT} || { echo "Failed to compile C++ application with static library"; return 1; }
        else
            ${PREFIX}g++ test_cpp_file.cpp -L. -l${LIB_NAME}_mixed -o mixed_test_static${EXE_EXT} || { echo "Failed to compile C++ application with static library"; return 1; }
        fi
        
        echo "Testing dynamic linking..."
        if [ "$PREFIX" = "x86_64-w64-mingw32-" ]; then
            ${PREFIX}g++ -std=c++11 test_cpp_file.cpp -L. -l${LIB_NAME}_mixed -o mixed_test_dynamic${EXE_EXT} || { echo "Failed to compile C++ application with dynamic library"; return 1; }
        else
            ${PREFIX}g++ test_cpp_file.cpp -L. -l${LIB_NAME}_mixed -Wl,-rpath,. -o mixed_test_dynamic${EXE_EXT} || { echo "Failed to compile C++ application with dynamic library"; return 1; }
        fi
        
        echo "Mixed C/C++ compilation successful!"
        
        # Try to run the tests (only for native compilation)
        if [ -z "$PREFIX" ]; then
            echo "Running static test..."
            if ./mixed_test_static${EXE_EXT}; then
                echo "Static test execution successful!"
            else
                echo "Static test execution failed, but compilation was successful"
            fi
            
            echo "Running dynamic test..."
            if ./mixed_test_dynamic${EXE_EXT}; then
                echo "Dynamic test execution successful!"
            else
                echo "Dynamic test execution failed, but compilation was successful"
            fi
        else
            echo "Cross-compiled executables: mixed_test_static${EXE_EXT} and mixed_test_dynamic${EXE_EXT}"
        fi
    fi

    # Clean up object files
    echo "Cleaning up object files..."
    rm -f *.o

    echo "Build complete!"
    return 0
}

# Main script execution
echo "========================================================================"
echo "Building mpack library with Native GCC (Mixed C/C++ Test)"
echo "========================================================================"

LIB_NAME=mpack
PREFIX=""
TEST_MIXED=1
EXE_EXT=""
SHARED_EXT=".so"

if ! compile; then
    echo "Build failed!"
    rm -f *.o
    exit 1
fi

echo
echo "========================================================================"
echo "Building mpack library with MinGW (Mixed C/C++ Test)"
echo "========================================================================"

LIB_NAME=mpack
PREFIX="x86_64-w64-mingw32-"
TEST_MIXED=1
EXE_EXT=".exe"
SHARED_EXT=".dll"

# Check if MinGW is available
if command -v x86_64-w64-mingw32-gcc &> /dev/null; then
    if ! compile; then
        echo "MinGW build failed!"
        rm -f *.o
        exit 1
    fi
else
    echo "MinGW cross-compiler not found. Install with:"
    echo "  sudo apt update"
    echo "  sudo apt install gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64"
    echo "Skipping MinGW build..."
fi

echo
echo "========================================================================"
echo "Build Summary"
echo "========================================================================"
echo "Libraries created:"
echo "Static libraries:"
echo "  - libmpack.a (mpack only)"
echo "  - libmpack_mixed.a (mpack + C code)"
echo "Dynamic libraries:"
echo "  - libmpack.so (Linux) / libmpack.dll (Windows)"
echo "  - libmpack_mixed.so (Linux) / libmpack_mixed.dll (Windows)"
echo "Executables:"
echo "  - mixed_test_static (statically linked)"
echo "  - mixed_test_dynamic (dynamically linked)"
if command -v x86_64-w64-mingw32-gcc &> /dev/null; then
    echo "  - mixed_test_static.exe (Windows, static)"
    echo "  - mixed_test_dynamic.exe (Windows, dynamic)"
fi
echo
echo "Test files created:"
echo "  - test_c_file.c (C code using mpack)"
echo "  - test_cpp_file.cpp (C++ code using mpack and calling C function)"
echo
echo "To use in your projects:"
echo "Static linking:"
echo "  gcc main.c -L. -lmpack -o program"
echo "  g++ main.cpp -L. -lmpack -o program"
echo "Dynamic linking:"
echo "  gcc main.c -L. -lmpack -Wl,-rpath,. -o program"
echo "  g++ main.cpp -L. -lmpack -Wl,-rpath,. -o program"
echo "========================================================================"

# Clean up test files
echo
read -p "Clean up test files? (y/n): " cleanup
if [[ "$cleanup" =~ ^[Yy]$ ]]; then
    rm -f test_c_file.c test_cpp_file.cpp
    echo "Test files cleaned up."
fi

echo "Script completed!"

• Used direct function calls instead of inline wrappers
• See test_c_file.c and test_cpp_file.cpp
• The scripts create both static and dynamic libs for both linux and windows