Build a JIT into a shared lib (when you're feeling a little too sane)

Author: sanko

.github/workflows/ci.yml

@@ -32,14 +32,13 @@ jobs:
       matrix:
         platform:
           - os: 'freebsd'
-            #~ version: '14.3'
             version: '15.0'
             prepare_gcc:   'pkg install -y perl5 lang/gcc'
             prepare_clang: 'pkg install -y perl5 llvm'
           - os: 'openbsd'
             version: '7.8'
             #~ https://openbsd.app/
-            prepare_gcc:   'pkg_add gcc-11.2.0p19'
+            prepare_gcc:   'pkg_add gcc-11.2.0p19 g++-11.2.0p19'
             prepare_clang: ''
           - os: 'netbsd'
             version: '10.1'
@@ -51,7 +50,7 @@ jobs:
             version: '11.4'
             prepare_gcc:   'pkg install -v --accept perl-538 gcc'
           - os: 'omnios'
-            version: 'r151054'
+            version: 'r151056'
             prepare_gcc:   'pkg install -v --accept perl build-essential'
         arch: ['x86_64', 'aarch64', 'riscv64']
         toolchain: ['gcc', 'clang']

.github/workflows/unified-tester.yml

@@ -59,7 +59,7 @@ jobs:
 
       - name: Build and Test in FreeBSD
         if: inputs.runner_type == 'vm' && inputs.os == 'freebsd'
-        uses: vmactions/freebsd-vm@v1.2.7
+        uses: vmactions/freebsd-vm@v1.3.7
         with:
           release: ${{ inputs.os_version }}
           usesh: true
@@ -70,7 +70,7 @@ jobs:
 
       - name: Build and Test in OpenBSD
         if: inputs.runner_type == 'vm' && inputs.os == 'openbsd'
-        uses: vmactions/openbsd-vm@v1.2.3
+        uses: vmactions/openbsd-vm@v1.3.1
         with:
           release: ${{ inputs.os_version }}
           usesh: true
@@ -81,7 +81,7 @@ jobs:
 
       - name: Build and Test in NetBSD
         if: inputs.runner_type == 'vm' && inputs.os == 'netbsd'
-        uses: vmactions/netbsd-vm@v1.2.2
+        uses: vmactions/netbsd-vm@v1.3.1
         with:
           release: ${{ inputs.os_version }}
           usesh: true
@@ -92,7 +92,7 @@ jobs:
 
       - name: Build and Test in DragonflyBSD
         if: inputs.runner_type == 'vm' && inputs.os == 'dragonflybsd'
-        uses: vmactions/dragonflybsd-vm@v1.1.3
+        uses: vmactions/dragonflybsd-vm@v1.2.1
         with:
           release: ${{ inputs.os_version }}
           usesh: true
@@ -102,7 +102,7 @@ jobs:
 
       - name: Build and Test in Solaris
         if: inputs.runner_type == 'vm' && inputs.os == 'solaris'
-        uses: vmactions/solaris-vm@v1.1.7
+        uses: vmactions/solaris-vm@v1.2.6
         with:
           release: ${{ inputs.os_version }}
           usesh: true
@@ -112,7 +112,7 @@ jobs:
 
       - name: Build and Test in OmniOS
         if: inputs.runner_type == 'vm' && inputs.os == 'omnios'
-        uses: vmactions/omnios-vm@v1.1.3
+        uses: vmactions/omnios-vm@v1.2.1
         with:
           release: ${{ inputs.os_version }}
           usesh: true

.gitignore

@@ -37,3 +37,17 @@ latex/*
 leak-*
 .tidyall.d/*
 docs/api/
+
+# Build artifacts and extensionless binaries
+*.so
+*.dylib
+*.dll
+fuzz_*_harness
+preprocessed.cpp
+
+# Ignore extensionless binaries in t/ but keep sources and include dir
+t/*
+!t/include/
+!t/*.c
+!t/*.cpp
+!t/*.h

CMakeLists.txt

@@ -1,6 +1,14 @@
 # CMake build script for the infix FFI library
 cmake_minimum_required(VERSION 3.12)
-project(infix VERSION 0.1.0 LANGUAGES C)
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/infix/infix.h" INFIX_MAJOR_LINE REGEX "^#define INFIX_MAJOR")
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/infix/infix.h" INFIX_MINOR_LINE REGEX "^#define INFIX_MINOR")
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/infix/infix.h" INFIX_PATCH_LINE REGEX "^#define INFIX_PATCH")
+
+string(REGEX MATCH "[0-9]+" INFIX_MAJOR "${INFIX_MAJOR_LINE}")
+string(REGEX MATCH "[0-9]+" INFIX_MINOR "${INFIX_MINOR_LINE}")
+string(REGEX MATCH "[0-9]+" INFIX_PATCH "${INFIX_PATCH_LINE}")
+
+project(infix VERSION ${INFIX_MAJOR}.${INFIX_MINOR}.${INFIX_PATCH} LANGUAGES C CXX)
 
 # Set the C standard to C17 and make it a requirement.
 set(CMAKE_C_STANDARD 17)
@@ -9,14 +17,20 @@ set(CMAKE_C_STANDARD_REQUIRED ON)
 # Use the standard GNUInstallDirs module to define portable installation paths.
 include(GNUInstallDirs)
 
-# Add the static library target.
-# Since infix uses a unity build, we only need to specify the main infix.c file.
-add_library(infix STATIC src/infix.c)
+# Add the library target.
+# If BUILD_SHARED_LIBS is set to ON, this will generate a shared library.
+add_library(infix src/infix.c)
 
 # Default to hidden visibility to avoid polluting the global symbol table
 # with internal functions (like _infix_set_error) when linked.
 set_target_properties(infix PROPERTIES C_VISIBILITY_PRESET hidden)
 
+# If building as a shared library, define INFIX_BUILDING_DLL to export symbols on Windows.
+get_target_property(INFIX_TARGET_TYPE infix TYPE)
+if(INFIX_TARGET_TYPE STREQUAL "SHARED_LIBRARY")
+    target_compile_definitions(infix PRIVATE INFIX_BUILDING_DLL)
+endif()
+
 if(INFIX_DEBUG_ENABLED)
     target_compile_definitions(infix PRIVATE
         INFIX_DEBUG_ENABLED=1
@@ -78,6 +92,20 @@ function(add_infix_test test_name)
         target_sources("${test_name}" PRIVATE "fuzz/fuzz_helpers.c")
         target_include_directories("${test_name}" PRIVATE fuzz)
     endif()
+    
+    # Special handling for 880_exports: Link against shared library if available
+    if(test_name STREQUAL "880_exports")
+        if(BUILD_SHARED_LIBS)
+            # Force linkage against the shared library target
+            target_link_libraries("${test_name}" PRIVATE infix)
+            # Define INFIX_USING_DLL on Windows to ensure correct import
+            if(WIN32)
+                target_compile_definitions("${test_name}" PRIVATE INFIX_USING_DLL)
+            endif()
+        endif()
+        # Enable exports from the executable so it can dlsym itself
+        set_target_properties("${test_name}" PROPERTIES ENABLE_EXPORTS ON)
+    endif()
 
     target_compile_definitions(${test_name} PRIVATE
         DBLTAP_ENABLE=1
@@ -102,7 +130,7 @@ endfunction()
 
 # Add all test targets using the helper function.
 # CONFIGURE_DEPENDS ensures CMake re-runs if you add/remove files in this directory.
-file(GLOB TEST_SOURCES CONFIGURE_DEPENDS "t/*.c")
+file(GLOB TEST_SOURCES CONFIGURE_DEPENDS "t/*.c" "t/*.cpp")
 
 foreach(test_source ${TEST_SOURCES})
     # Extract the filename without the extension ("t/001_primitives.c" => "001_primitives")
@@ -113,7 +141,26 @@ foreach(test_source ${TEST_SOURCES})
          continue()
     endif()
 
-    add_infix_test("${test_name}")
+    # The function add_infix_test assumes .c, but we now have .cpp. 
+    # Let's adjust the logic slightly or handle it here.
+    # Since add_infix_test is a bit rigid, let's call add_executable directly for C++ 
+    # or modify add_infix_test. For minimal changes, let's update add_infix_test to take source.
+
+    if (test_source MATCHES "\\.cpp$")
+         # Manual handling for C++ test
+         add_executable("${test_name}" "${test_source}")
+         target_include_directories("${test_name}" PRIVATE "t/include" "${CMAKE_CURRENT_SOURCE_DIR}/src")
+         target_link_libraries("${test_name}" PRIVATE infix)
+         if(UNIX)
+            target_link_libraries("${test_name}" PRIVATE m)
+         endif()
+         target_compile_definitions(${test_name} PRIVATE DBLTAP_ENABLE=1 INFIX_DEBUG_ENABLED=1)
+         
+         # SIMD flags logic duplicated for C++... simpler to just assume standard flags or none for this compat test.
+         add_test(NAME "${test_name}" COMMAND "${test_name}")
+    else()
+         add_infix_test("${test_name}")
+    endif()
 endforeach()
 
 # cmake -DINFIX_DEBUG_ENABLED=1 -B build ; cmake --build build ; ctest --test-dir build --rerun-failed --output-on-failure

Makefile

@@ -4,6 +4,7 @@
 #
 
 CC       := gcc
+CXX      := g++
 AR       := ar
 PERL     := perl
 ARFLAGS  := rcs
@@ -64,38 +65,52 @@ ifeq ($(OS),Windows_NT)
     LIB_TARGET   := libinfix.a
     LDFLAGS      := -lkernel32
     CLEAN_CMD    := del /F /Q
+    EXPORT_FLAGS := -Wl,--export-all-symbols
+    SO_EXT       := dll
 else
     # Native POSIX (Linux, macOS, BSD) Configuration
     EXE_EXT      :=
-    LRT_FLAG     := $(shell printf '#include <sys/mman.h>\n#include <fcntl.h>\nint main() { shm_open("", 0, 0); return 0; }' > .check_lrt.c; if $(CC) .check_lrt.c -o .check_lrt.out -lrt >/dev/null 2>&1; then printf -- "-lrt"; fi; rm -f .check_lrt.c .check_lrt.out)
+    LRT_FLAG     := $(shell printf '#include <sys/mman.h>\n#include <fcntl.h>\nint main() { shm_open(\"\", 0, 0); return 0; }' > .check_lrt.c; if $(CC) .check_lrt.c -o .check_lrt.out -lrt >/dev/null 2>&1; then printf -- "-lrt"; fi; rm -f .check_lrt.c .check_lrt.out)
     ifeq ($(LRT_FLAG),-lrt)
         $(info Linker check: -lrt is required and will be added.)
     endif
     LDFLAGS      := -lpthread $(LRT_FLAG) -ldl
     LIB_TARGET   := libinfix.a
     CLEAN_CMD    := rm -f
+    EXPORT_FLAGS := -rdynamic
+    SO_EXT       := so
 endif
 
 # Finalize Source and Object Lists
 LIB_SRCS := $(BASE_SRCS)
 LIB_OBJS := $(LIB_SRCS:.c=.o)
+SHARED_LIB_OBJS := $(LIB_SRCS:.c=.shared.o)
 
-TEST_SRCS   := $(wildcard t/*.c)
-TEST_TARGETS:= $(patsubst %.c,%$(EXE_EXT),$(TEST_SRCS))
+TEST_SRCS   := $(wildcard t/*.c) $(wildcard t/*.cpp)
+TEST_TARGETS:= $(patsubst t/%.c,t/%$(EXE_EXT),$(filter %.c,$(TEST_SRCS)))
+TEST_TARGETS+= $(patsubst t/%.cpp,t/%$(EXE_EXT),$(filter %.cpp,$(TEST_SRCS)))
 
 # Target-Specific Variables for Special Test Cases
 # Define extra source files and flags needed ONLY for the regression test.
 t/850_regression_cases$(EXE_EXT)_EXTRA_SRCS := fuzz/fuzz_helpers.c
 t/850_regression_cases$(EXE_EXT)_EXTRA_CFLAGS := -Ifuzz
 
+# 880_exports needs to export its own symbols to test dlsym(NULL)
+t/880_exports$(EXE_EXT)_EXTRA_LDFLAGS := $(EXPORT_FLAGS)
+
 # Build Targets
-.PHONY: all test clean
+.PHONY: all test clean shared
 
 # Default target: Build only the static library.
 all: $(LIB_TARGET)
 	@echo
 	@echo "Library '$(LIB_TARGET)' built successfully."
 
+# Shared library target
+shared: libinfix.$(SO_EXT)
+	@echo
+	@echo "Shared Library 'libinfix.$(SO_EXT)' built successfully."
+
 # Test target: Build all test executables, then run them using the embedded Perl script.
 test: $(TEST_TARGETS)
 	@echo
@@ -107,22 +122,37 @@ $(LIB_TARGET): $(LIB_OBJS)
 	@echo "AR  $@"
 	$(AR) $(ARFLAGS) $@ $^
 
-# Generic pattern rule to build a test executable.
-# It uses automatic variables like `$@` (the target) and `$<` (the first prerequisite)
-# and also checks for our target-specific variables.
-$(TEST_TARGETS): %$(EXE_EXT): %.c $(LIB_TARGET)
+# Rule to build the shared library
+libinfix.$(SO_EXT): $(SHARED_LIB_OBJS)
 	@echo "LD  $@"
-	$(CC) $(TEST_CFLAGS) $($(@)_EXTRA_CFLAGS) $< $($(@)_EXTRA_SRCS) -o $@ -L. -linfix $(LDFLAGS)
+	$(CC) -shared -o $@ $^ $(LDFLAGS)
+
+# Generic pattern rule to build a C test executable.
+t/%$(EXE_EXT): t/%.c $(LIB_TARGET)
+	@echo "LD (C)  $@"
+	$(CC) $(TEST_CFLAGS) $($(@)_EXTRA_CFLAGS) $< $($(@)_EXTRA_SRCS) -o $@ -L. -linfix $(LDFLAGS) $($(@)_EXTRA_LDFLAGS)
+
+# Generic pattern rule to build a C++ test executable.
+t/%$(EXE_EXT): t/%.cpp $(LIB_TARGET)
+	@echo "LD (C++) $@"
+	$(CXX) $(TEST_CFLAGS) $($(@)_EXTRA_CFLAGS) $< $($(@)_EXTRA_SRCS) -o $@ -L. -linfix $(LDFLAGS) $($(@)_EXTRA_LDFLAGS)
 
 # Generic rule to compile library .c files to .o files, using LIB_CFLAGS
 %.o: %.c
 	@echo "CC  $<"
 	$(CC) $(LIB_CFLAGS) -c $< -o $@
 
+# Rule to compile for shared library (with -fPIC and -DINFIX_BUILDING_DLL)
+%.shared.o: %.c
+	@echo "CC (Shared) $<"
+	$(CC) $(LIB_CFLAGS) -fPIC -DINFIX_BUILDING_DLL -c $< -o $@
+
 # Clean up build artifacts
 clean:
 	@echo "CLEAN"
-	-$(CLEAN_CMD) $(subst /,\,$(LIB_OBJS))
-	-$(CLEAN_CMD) $(subst /,\,$(TEST_TARGETS))
-	-$(CLEAN_CMD) $(subst /,\,$(LIB_TARGET))
+	-$(CLEAN_CMD) $(subst /uyễn,uyễn,$(LIB_OBJS))
+	-$(CLEAN_CMD) $(subst /uyễn,uyễn,$(SHARED_LIB_OBJS))
+	-$(CLEAN_CMD) $(subst /uyễn,uyễn,$(TEST_TARGETS))
+	-$(CLEAN_CMD) $(subst /uyễn,uyễn,$(LIB_TARGET))
+	-$(CLEAN_CMD) libinfix.so libinfix.dll infix.dll infix.lib infix.exp
 	-rm -f .check_lrt.out

Makefile.win

@@ -30,18 +30,25 @@ LIB_OBJECTS = $(OBJ_DIR)\infix.obj
 # --- Main Targets ---
 all: $(OBJ_DIR)\$(LIB_NAME)
 
+shared: $(OBJ_DIR)\infix.dll
+
 # --- Build Rules ---
 
 # Rule to create the static library from its object files.
 $(OBJ_DIR)\$(LIB_NAME): $(LIB_OBJECTS)
     @echo AR $@
     $(LIB) /OUT:$@ $(LIB_OBJECTS)
 
+# Rule to create the dynamic library (DLL).
+$(OBJ_DIR)\infix.dll: $(LIB_OBJECTS)
+    @echo LD $@
+    $(CC) /LD /Fe$@ $(LIB_OBJECTS) /link /DLL
+
 # Inference Rule to build .obj files from .c files found in the core source directory.
 {$(SRC_DIR)}.c{$(OBJ_DIR)}.obj:
     @if not exist $(OBJ_DIR) mkdir $(OBJ_DIR)
     @echo CC $**
-    $(CC) $(CFLAGS) /c $** /Fo$@
+    $(CC) $(CFLAGS) /DINFIX_BUILDING_DLL /c $** /Fo$@
 
 # --- Cleanup ---
 clean:

README.md

@@ -137,6 +137,8 @@ The easiest way to use `infix` is to add its source directly to your project.
 3.  Add the `include/` directory to your include paths.
 4.  `#include <infix/infix.h>` in your code.
 
+> **Note:** If you are linking against `infix` as a shared library (DLL) on Windows, you must define `INFIX_USING_DLL` in your project settings. See the [Installation Guide](docs/INSTALL.md) for details.
+
 For more advanced build options, including building as a standalone library with CMake or xmake, see the [Building and Integration Guide](docs/INSTALL.md).
 
 ## Project Philosophy

SECURITY.md

@@ -10,8 +10,8 @@ Security updates are provided for the latest public release. As this is a pre-1.
 
 | Version       | Supported          |
 | ------------- | ------------------ |
-| >= 0.1.0      | :white_check_mark: |
-| < 0.1.0       | :x:                |
+| >= 0.1.3      | :white_check_mark: |
+| < 0.1.3       | :x:                |
 | [unversioned] | :white_check_mark: |
 
 ## Reporting a Vulnerability