ffi 1.15.5 → 1.17.0

data/ext/ffi_c/libffi/testsuite/emscripten/build-tests.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+emcc_exists="$(command -v emcc)"
+if [ ! "${emcc_exists}" ]; then
+  echo "Emscripten not on path"
+  exit 1
+fi
+
+set -e
+
+cd "$1"
+shift
+
+# Parse arguments
+while [ $# -gt 0 ]; do
+  case $1 in
+  --wasm-bigint) WASM_BIGINT=true ;;
+  *)
+    echo "ERROR: Unknown parameter: $1" >&2
+    exit 1
+    ;;
+  esac
+  shift
+done
+
+
+export CFLAGS="-fPIC -O2 -I../../target/include $EXTRA_CFLAGS"
+export CXXFLAGS="$CFLAGS -sNO_DISABLE_EXCEPTION_CATCHING $EXTRA_CXXFLAGS"
+export LDFLAGS=" \
+    -L../../target/lib/ -lffi \
+    -sEXPORT_ALL \
+    -sMODULARIZE \
+    -sMAIN_MODULE \
+    -sNO_DISABLE_EXCEPTION_CATCHING \
+    $EXTRA_LD_FLAGS \
+"
+
+# This needs to test false if there exists an environment variable called
+# WASM_BIGINT whose contents are empty. Don't use +x.
+if [ -n "${WASM_BIGINT}" ] ; then
+  export LDFLAGS+=" -sWASM_BIGINT"
+else
+  export LDFLAGS+=" -sEXPORTED_RUNTIME_METHODS='getTempRet0,setTempRet0'"
+fi
+
+# Rename main functions to test__filename so we can link them together
+ls *c | sed 's!\(.*\)\.c!sed -i "s/main/test__\1/g" \0!g' | bash
+
+# Compile
+ls *.c | sed 's/\(.*\)\.c/emcc $CFLAGS -c \1.c -o \1.o /g' | bash
+ls *.cc | sed 's/\(.*\)\.cc/em++ $CXXFLAGS -c \1.cc -o \1.o /g' | bash
+
+# Link
+em++ $LDFLAGS *.o -o test.js
+cp ../emscripten/test.html .

data/ext/ffi_c/libffi/testsuite/emscripten/build.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+command -v emcc >/dev/null 2>&1 || {
+  echo >&2 "emsdk could not be found.  Aborting."
+  exit 1
+}
+
+set -e
+
+SOURCE_DIR=$PWD
+
+# Working directories
+TARGET=$SOURCE_DIR/target
+mkdir -p "$TARGET"
+
+# Define default arguments
+
+# JS BigInt to Wasm i64 integration, disabled by default
+# This needs to test false if there exists an environment variable called
+# WASM_BIGINT whose contents are empty. Don't use +x.
+if [ -n "${WASM_BIGINT}" ]; then
+  WASM_BIGINT=true
+else
+  WASM_BIGINT=false
+fi
+
+# Parse arguments
+while [ $# -gt 0 ]; do
+  case $1 in
+  --wasm-bigint) WASM_BIGINT=true ;;
+  --debug) DEBUG=true ;;
+  *)
+    echo "ERROR: Unknown parameter: $1" >&2
+    exit 1
+    ;;
+  esac
+  shift
+done
+
+# Common compiler flags
+export CFLAGS="-O3 -fPIC"
+if [ "$WASM_BIGINT" = "true" ]; then
+  # We need to detect WASM_BIGINT support at compile time
+  export CFLAGS+=" -DWASM_BIGINT"
+fi
+if [ "$DEBUG" = "true" ]; then
+  export CFLAGS+=" -DDEBUG_F"
+fi
+export CXXFLAGS="$CFLAGS"
+
+# Build paths
+export CPATH="$TARGET/include"
+export PKG_CONFIG_PATH="$TARGET/lib/pkgconfig"
+export EM_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
+
+# Specific variables for cross-compilation
+export CHOST="wasm32-unknown-linux" # wasm32-unknown-emscripten
+
+autoreconf -fiv
+emconfigure ./configure --host=$CHOST --prefix="$TARGET" --enable-static --disable-shared --disable-dependency-tracking \
+  --disable-builddir --disable-multi-os-directory --disable-raw-api --disable-docs
+make install
+cp fficonfig.h target/include/
+cp include/ffi_common.h target/include/

data/ext/ffi_c/libffi/testsuite/emscripten/conftest.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+from pytest import fixture
+from pytest_pyodide.server import spawn_web_server
+from pytest_pyodide import runner
+
+import logging
+
+TEST_PATH = Path(__file__).parents[1].resolve()
+
+
+class BaseRunner(runner._BrowserBaseRunner):
+    def __init__(
+        self,
+        *args,
+        test_dir,
+        **kwargs,
+    ):
+        self.test_dir = test_dir
+        super().__init__(
+            *args,
+            **kwargs,
+            load_pyodide=False,
+        )
+
+    def prepare_driver(self):
+        self.base_url = (
+            f"http://{self.server_hostname}:{self.server_port}/{self.test_dir}/"
+        )
+        self.goto(f"{self.base_url}/test.html")
+
+    def javascript_setup(self):
+        self.run_js("globalThis.TestModule = await globalThis.Module();")
+
+
+class FirefoxRunner(BaseRunner, runner.SeleniumFirefoxRunner):
+    pass
+
+
+class ChromeRunner(BaseRunner, runner.SeleniumChromeRunner):
+    pass
+
+
+# TODO: Figure out how to get NodeRunner to work.
+
+RUNNER_DICT = {x.browser: x for x in [FirefoxRunner, ChromeRunner]}
+
+
+@fixture(params=list(RUNNER_DICT), scope="class")
+def selenium_class_scope(request, web_server_main):
+    server_hostname, server_port, server_log = web_server_main
+    assert request.param in RUNNER_DICT
+
+    logger = logging.getLogger('selenium')
+    logger.setLevel(logging.DEBUG)
+
+    cls = RUNNER_DICT[request.param]
+    selenium = cls(
+        test_dir=request.cls.TEST_BUILD_DIR,
+        server_port=server_port,
+        server_hostname=server_hostname,
+        server_log=server_log,
+    )
+    request.cls.call_number = 0
+    try:
+        yield selenium
+    finally:
+        print(selenium.logs)
+        selenium.driver.quit()
+
+
+@fixture(scope="function")
+def selenium(selenium_class_scope, request):
+    selenium = selenium_class_scope
+    request.cls.call_number += 1
+    # Refresh page every 50 calls to prevent firefox out of memory errors
+    if request.cls.call_number % 50 == 0:
+        selenium.driver.refresh()
+        selenium.javascript_setup()
+    selenium.clean_logs()
+    yield selenium
+
+
+@fixture(scope="session")
+def web_server_main(request):
+    with spawn_web_server(TEST_PATH) as output:
+        yield output

data/ext/ffi_c/libffi/testsuite/emscripten/node-tests.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# JS BigInt to Wasm i64 integration, disabled by default
+WASM_BIGINT=false
+
+emcc_exists="$(command -v emcc)"
+if [ ! "${emcc_exists}" ]; then
+  echo "Emscripten not on path"
+  exit 1
+fi
+
+# Parse arguments
+while [ $# -gt 0 ]; do
+  case $1 in
+  --wasm-bigint) WASM_BIGINT=true ;;
+  *)
+    echo "ERROR: Unknown parameter: $1" >&2
+    exit 1
+    ;;
+  esac
+  shift
+done
+
+# Common compiler flags
+export CFLAGS="-fPIC $EXTRA_CFLAGS"
+if [ "$WASM_BIGINT" = "true" ]; then
+  # We need to detect WASM_BIGINT support at compile time
+  export CFLAGS+=" -DWASM_BIGINT"
+fi
+export CXXFLAGS="$CFLAGS -sNO_DISABLE_EXCEPTION_CATCHING $EXTRA_CXXFLAGS"
+export LDFLAGS="-sEXPORTED_FUNCTIONS=_main,_malloc,_free -sALLOW_TABLE_GROWTH -sASSERTIONS -sNO_DISABLE_EXCEPTION_CATCHING"
+if [ "$WASM_BIGINT" = "true" ]; then
+  export LDFLAGS+=" -sWASM_BIGINT"
+else
+  export LDFLAGS+=" -sEXPORTED_RUNTIME_METHODS='getTempRet0,setTempRet0'"
+fi
+
+# Specific variables for cross-compilation
+export CHOST="wasm32-unknown-linux" # wasm32-unknown-emscripten
+
+autoreconf -fiv
+emconfigure ./configure --prefix="$(pwd)/target" --host=$CHOST --enable-static --disable-shared \
+  --disable-builddir --disable-multi-os-directory --disable-raw-api --disable-docs ||
+  (cat config.log && exit 1)
+make
+
+EMMAKEN_JUST_CONFIGURE=1 emmake make check \
+  RUNTESTFLAGS="LDFLAGS_FOR_TARGET='$LDFLAGS'" || (cat testsuite/libffi.log && exit 1)

data/ext/ffi_c/libffi/testsuite/emscripten/test.html

@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script src="test.js"></script>
+  </head>
+  <body></body>
+</html>

data/ext/ffi_c/libffi/testsuite/emscripten/test_libffi.py

@@ -0,0 +1,51 @@
+import subprocess
+import pathlib
+import pytest
+
+TEST_PATH = pathlib.Path(__file__).parents[1].resolve()
+
+xfails = {}
+
+
+def libffi_tests(self, selenium, libffi_test):
+    if libffi_test in xfails:
+        pytest.xfail(f'known failure with code "{xfails[libffi_test]}"')
+    res = selenium.run_js(
+        """
+        window.TestModule = await Module();
+        """
+    )
+    selenium.run_js(
+        f"""
+        try {{
+            TestModule._test__{libffi_test}();
+        }} catch(e){{
+            if(e.name !== "ExitStatus"){{
+                throw e;
+            }}
+            if(e.status !== 0){{
+                throw new Error(`Terminated with nonzero status code ${{e.status}}: ` + e.message);
+            }}
+        }}
+        """
+    )
+
+
+class TestCall:
+    TEST_BUILD_DIR = "libffi.call.test"
+    test_call = libffi_tests
+
+
+class TestClosures:
+    TEST_BUILD_DIR = "libffi.closures.test"
+    test_closures = libffi_tests
+
+
+def pytest_generate_tests(metafunc):
+    test_build_dir = metafunc.cls.TEST_BUILD_DIR
+    test_names = [x.stem for x in (TEST_PATH / test_build_dir).glob("*.o")]
+    metafunc.parametrize("libffi_test", test_names)
+
+
+if __name__ == "__main__":
+    subprocess.call(["build-tests.sh", "libffi.call"])

data/ext/ffi_c/libffi/testsuite/lib/libffi.exp

@@ -1,4 +1,4 @@
-#   Copyright (C) 2003, 2005, 2008, 2009, 2010, 2011, 2014, 2019 Free Software Foundation, Inc.
+#   Copyright (C) 2003, 2005, 2008, 2009, 2010, 2011, 2014, 2019, 2022 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -45,7 +45,7 @@ proc is-effective-target { arg } {
     if { [info procs check_effective_target_${arg}] != [list] } {
 	set selected [check_effective_target_${arg}]
     } else {
-	error "unknown effective target keyword `$arg'" 
+	error "unknown effective target keyword `$arg'"
     }
     verbose "is-effective-target: $arg $selected" 2
     return $selected
@@ -196,7 +196,7 @@ if { [info procs saved-dg-process-target] == [list] } {
 		return "N"
 	    }
 	    return [dg-process-target-1 $xfail_selector]
-	    
+
 	}
 	return [dg-process-target-1 $selector]
     }
@@ -221,6 +221,13 @@ proc libffi-dg-test-1 { target_compile prog do_what extra_tool_flags } {
 	set output_match [lreplace $output_match 1 1 $x]
     }
 
+    if { [ istarget "wasm32-*-*" ] } {
+        # emscripten will get confused if told to build as .exe
+        set exec_suffix ""
+    } else {
+        set exec_suffix ".exe"
+    }
+
     # Set up the compiler flags, based on what we're going to do.
 
     set options [list]
@@ -231,7 +238,7 @@ proc libffi-dg-test-1 { target_compile prog do_what extra_tool_flags } {
 	}
 	"link" {
 	    set compile_type "executable"
-	    set output_file "[file rootname [file tail $prog]].exe"
+	    set output_file "[file rootname [file tail $prog]]$exec_suffix"
 	    # The following line is needed for targets like the i960 where
 	    # the default output file is b.out.  Sigh.
 	}
@@ -240,7 +247,7 @@ proc libffi-dg-test-1 { target_compile prog do_what extra_tool_flags } {
 	    # FIXME: "./" is to cope with "." not being in $PATH.
 	    # Should this be handled elsewhere?
 	    # YES.
-	    set output_file "./[file rootname [file tail $prog]].exe"
+	    set output_file "./[file rootname [file tail $prog]]$exec_suffix"
 	    # This is the only place where we care if an executable was
 	    # created or not.  If it was, dg.exp will try to run it.
 	    remote_file build delete $output_file;
@@ -269,6 +276,10 @@ proc libffi-dg-test { prog do_what extra_tool_flags } {
 proc libffi-dg-prune { target_triplet text } {
     # We get this with some qemu emulated systems (eg. ppc64le-linux-gnu)
     regsub -all "(^|\n)\[^\n\]*unable to perform all requested operations" $text "" text
+    # We get this from sparc64 linux systems
+    regsub -all "(^|\n)\[^\n\]*warning: .* has a LOAD segment with RWX permissions" $text "" text
+    # Ignore Emscripten INFO messages
+    regsub -all "(^|\n)(cache|shared):INFO:\[^\n\]*" $text "" text
     return $text
 }
 
@@ -292,9 +303,6 @@ proc libffi-init { args } {
     verbose "libffi $blddirffi"
 
     # Which compiler are we building with?
-    set tmp [grep "$blddirffi/config.log" "^ax_cv_c_compiler_vendor.*$"]
-    regexp -- {^[^=]*=(.*)$} $tmp nil compiler_vendor
-
     if { [string match $compiler_vendor "gnu"] } {
         set gccdir [lookfor_file $tool_root_dir gcc/libgcc.a]
         if {$gccdir != ""} {
@@ -379,7 +387,9 @@ proc libffi_target_compile { source dest type options } {
 
     if { [istarget "*-*-darwin9*"] || [istarget "*-*-darwin1*"]
 	 || [istarget "*-*-darwin2*"] } {
-	lappend options "additional_flags=-Wl,-allow_stack_execute"
+	# lappend options "additional_flags=-Wl,-allow_stack_execute"
+        lappend options "additional_flags=-Wno-unused-command-line-argument"
+        lappend options "additional_flags=-Wl,-search_paths_first"
     }
 
     # If you're building the compiler with --prefix set to a place
@@ -397,17 +407,29 @@ proc libffi_target_compile { source dest type options } {
 
     lappend options "libs= -lffi"
 
-    if { [string match "aarch64*-*-linux*" $target_triplet] } {
-	lappend options "libs= -lpthread"
-    }
+    if { ![string match "*android*" $target_triplet] } {
+
+        if { [string match "aarch64*-*-linux*" $target_triplet] } {
+            lappend options "libs= -lpthread"
+        }
 
-    # this may be required for g++, but just confused clang.
-    if { [string match "*.cc" $source] } {
-        lappend options "c++"
+        # this may be required for g++, but just confused clang.
+        if { [string match "*.cc" $source] } {
+            lappend options "c++"
+            if { [string match "*-*-darwin*" $target_triplet] } {
+                lappend options "libs= -lc++"
+            }
+        }
+
+        if { [string match "arc*-*-linux*" $target_triplet] } {
+            lappend options "libs= -lpthread"
+        }
     }
 
-    if { [string match "arc*-*-linux*" $target_triplet] } {
-	lappend options "libs= -lpthread"
+    # emscripten emits this warning while building the feature test
+    # which causes it to be seen as unsupported.
+    if { [string match "wasm32-*" $target_triplet] } {
+        lappend options "additional_flags=-Wno-unused-command-line-argument"
     }
 
     verbose "options: $options"
@@ -489,7 +511,7 @@ proc run-many-tests { testcases extra_flags } {
         set common "-W -Wall"
         if [info exists env(LIBFFI_TEST_OPTIMIZATION)] {
 	  set optimizations [ list $env(LIBFFI_TEST_OPTIMIZATION) ]
-        } else { 
+        } else {
           set optimizations { "-O0" "-O2" }
         }
       }
@@ -497,7 +519,7 @@ proc run-many-tests { testcases extra_flags } {
         set common "-W -Wall -Wno-psabi"
         if [info exists env(LIBFFI_TEST_OPTIMIZATION)] {
 	  set optimizations [ list $env(LIBFFI_TEST_OPTIMIZATION) ]
-        } else { 
+        } else {
           set optimizations { "-O0" "-O2" }
         }
       }
@@ -506,7 +528,7 @@ proc run-many-tests { testcases extra_flags } {
         set common ""
         if [info exists env(LIBFFI_TEST_OPTIMIZATION)] {
 	  set optimizations [ list $env(LIBFFI_TEST_OPTIMIZATION) ]
-        } else { 
+        } else {
           set optimizations { "" }
         }
       }
@@ -595,7 +617,7 @@ proc check-flags { args } {
     # compare them to the actual options.
     if { [string compare [lindex $args 2] "*"] == 0
 	 && [string compare [lindex $args 3] "" ] == 0 } {
-	set result 1    
+	set result 1
     } else {
 	# The target list might be an effective-target keyword, so replace
 	# the original list with "*-*-*", since we already know it matches.

data/ext/ffi_c/libffi/testsuite/lib/target-libpath.exp

@@ -175,7 +175,7 @@ proc set_ld_library_path_env_vars { } {
   } else {
     setenv DYLD_LIBRARY_PATH "$ld_library_path"
   }
-  if { [istarget *-*-cygwin*] || [istarget *-*-mingw*] } {
+  if { [istarget *-*-cygwin*] || [ istarget *-*-msys* ] || [istarget *-*-mingw*] } {
     if { $orig_path_saved } {
       setenv PATH "$ld_library_path:$orig_path"
     } else {
@@ -271,7 +271,7 @@ proc get_shlib_extension { } {
 
     if { [ istarget *-*-darwin* ] } {
 	set shlib_ext "dylib"
-    } elseif { [ istarget *-*-cygwin* ] || [ istarget *-*-mingw* ] } {
+    } elseif { [ istarget *-*-cygwin* ] || [ istarget *-*-msys* ] || [ istarget *-*-mingw* ] } {
 	set shlib_ext "dll"
     } elseif { [ istarget hppa*-*-hpux* ] } {
 	set shlib_ext "sl"

data/ext/ffi_c/libffi/testsuite/libffi.bhaible/test-call.c

@@ -50,6 +50,7 @@ int _fprintf(FILE *stream, const char *format, ...)
     case 3:
       vsprintf(&rbuf2[strlen(rbuf2)], format, args);
       printf("%s", rbuf2);
+      fflush (stdout);
       if (strcmp (rbuf1, rbuf2)) abort();
       break;
     }

data/ext/ffi_c/libffi/testsuite/libffi.bhaible/testcases.c

@@ -64,7 +64,11 @@ typedef struct {
 typedef struct { char c[3]; } T;
 typedef struct { char c[33],c1; } X;
 
-char c1='a', c2=127, c3=(char)128, c4=(char)255, c5=-1;
+/* Don't use a number over 127, as some systems use signed chars and
+   the test case 25 doesn't account for this, resulting in undefined
+   behavior. See https://github.com/libffi/libffi/issues/598. */
+char c1='a', c2=127, c3=(char)1;
+
 short s1=32767, s2=(short)32768, s3=3, s4=4, s5=5, s6=6, s7=7, s8=8, s9=9;
 int i1=1, i2=2, i3=3, i4=4, i5=5, i6=6, i7=7, i8=8, i9=9,
     i10=11, i11=12, i12=13, i13=14, i14=15, i15=16, i16=17;

data/ext/ffi_c/libffi/testsuite/libffi.call/bpo_38748.c

@@ -0,0 +1,41 @@
+/* Area:	bpo-38748
+   Purpose:	test for stdcall alignment problem
+   Source:      github.com/python/cpython/pull/26204 */
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+#include "ffi_common.h"
+
+static UINT32 ABI_ATTR align_arguments(UINT32 l1,
+				       UINT64 l2)
+{
+  return l1 + (UINT32) l2;
+}
+
+int main(void)
+{
+  ffi_cif cif;
+  ffi_type *args[4] = {
+    &ffi_type_uint32,
+    &ffi_type_uint64
+  };
+  ffi_arg lr1, lr2;
+  UINT32 l1 = 1;
+  UINT64 l2 = 2;
+  void *values[2] = {&l1, &l2};
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2,
+		     &ffi_type_uint32, args) == FFI_OK);
+
+  lr1 = align_arguments(l1, l2);
+
+  ffi_call(&cif, FFI_FN(align_arguments), &lr2, values);
+
+  if (lr1 == lr2)
+    printf("bpo-38748 arguments tests ok!\n");
+  else
+    CHECK(0);
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.call/callback.c

@@ -0,0 +1,99 @@
+/* Area:	ffi_call
+   Purpose:	Check structures with array and callback.
+   Limitations:	none.
+   PR:		none.
+   Originator:	David Tenty <daltenty@ibm.com>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+int i=5;
+
+void callback(void) { i++; }
+
+typedef struct
+{
+  unsigned char c1;
+  double s[2];
+  unsigned char c2;
+} test_structure_12;
+
+static test_structure_12 ABI_ATTR struct12 (test_structure_12 ts, void (*func)(void))
+{
+  ts.c1 += 1;
+  ts.c2 += 1;
+  ts.s[0] += 1;
+  ts.s[1] += 1;
+
+  func();
+  return ts;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  ffi_type ts12_type,ts12a_type;
+  ffi_type *ts12_type_elements[4];
+  ffi_type *ts12a_type_elements[3];
+
+  test_structure_12 ts12_arg;
+  void (*ptr)(void)=&callback;
+
+  test_structure_12 *ts12_result =
+    (test_structure_12 *) malloc (sizeof(test_structure_12));
+
+  ts12a_type.size = 0;
+  ts12a_type.alignment = 0;
+  ts12a_type.type = FFI_TYPE_STRUCT;
+  ts12a_type.elements = ts12a_type_elements;
+  ts12a_type_elements[0] = &ffi_type_double;
+  ts12a_type_elements[1] = &ffi_type_double;
+  ts12a_type_elements[2] = NULL;
+
+  ts12_type.size = 0;
+  ts12_type.alignment = 0;
+  ts12_type.type = FFI_TYPE_STRUCT;
+  ts12_type.elements = ts12_type_elements;
+  ts12_type_elements[0] = &ffi_type_uchar;
+  ts12_type_elements[1] = &ts12a_type;
+  ts12_type_elements[2] = &ffi_type_uchar;
+  ts12_type_elements[3] = NULL;
+
+
+  args[0] = &ts12_type;
+  args[1] = &ffi_type_pointer;
+  values[0] = &ts12_arg;
+  values[1] = &ptr;
+
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2, &ts12_type, args) == FFI_OK);
+
+  ts12_arg.c1 = 5;
+  ts12_arg.c2 = 6;
+  ts12_arg.s[0] = 7.77;
+  ts12_arg.s[1] = 8.88;
+
+  printf ("%u\n", ts12_arg.c1);
+  printf ("%u\n", ts12_arg.c2);
+  printf ("%g\n", ts12_arg.s[0]);
+  printf ("%g\n", ts12_arg.s[1]);
+  printf ("%d\n", i);
+
+  ffi_call(&cif, FFI_FN(struct12), ts12_result, values);
+
+  printf ("%u\n", ts12_result->c1);
+  printf ("%u\n", ts12_result->c2);
+  printf ("%g\n", ts12_result->s[0]);
+  printf ("%g\n", ts12_result->s[1]);
+  printf ("%d\n", i);
+  CHECK(ts12_result->c1 == 5 + 1);
+  CHECK(ts12_result->c2 == 6 + 1);
+  CHECK(ts12_result->s[0] == 7.77 + 1);
+  CHECK(ts12_result->s[1] == 8.88 + 1);
+  CHECK(i == 5 + 1);
+  CHECK(ts12_type.size == sizeof(test_structure_12));
+
+  free (ts12_result);
+  exit(0);
+}