Add files using upload-large-folder tool

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/include/ffitarget.h

@@ -0,0 +1,164 @@
+/* -----------------------------------------------------------------*-C-*-
+   ffitarget.h - Copyright (c) 2012, 2014, 2018  Anthony Green
+                 Copyright (c) 1996-2003, 2010  Red Hat, Inc.
+                 Copyright (C) 2008  Free Software Foundation, Inc.
+
+   Target configuration macros for x86 and x86-64.
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   ``Software''), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be included
+   in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+
+   ----------------------------------------------------------------------- */
+
+#ifndef LIBFFI_TARGET_H
+#define LIBFFI_TARGET_H
+
+#ifndef LIBFFI_H
+#error "Please do not include ffitarget.h directly into your source.  Use ffi.h instead."
+#endif
+
+/* ---- System specific configurations ----------------------------------- */
+
+/* For code common to all platforms on x86 and x86_64. */
+#define X86_ANY
+
+#if defined (X86_64) && defined (__i386__)
+#undef X86_64
+#warning ******************************************************
+#warning ********** X86 IS DEFINED ****************************
+#warning ******************************************************
+#define X86
+#endif
+
+#ifdef X86_WIN64
+#define FFI_SIZEOF_ARG 8
+#define USE_BUILTIN_FFS 0 /* not yet implemented in mingw-64 */
+#endif
+
+#define FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION
+#ifndef _MSC_VER
+#define FFI_TARGET_HAS_COMPLEX_TYPE
+#endif
+
+/* ---- Generic type definitions ----------------------------------------- */
+
+#ifndef LIBFFI_ASM
+#ifdef X86_WIN64
+#ifdef _MSC_VER
+typedef unsigned __int64       ffi_arg;
+typedef __int64                ffi_sarg;
+#else
+typedef unsigned long long     ffi_arg;
+typedef long long              ffi_sarg;
+#endif
+#else
+#if defined __x86_64__ && defined __ILP32__
+#define FFI_SIZEOF_ARG 8
+#define FFI_SIZEOF_JAVA_RAW  4
+typedef unsigned long long     ffi_arg;
+typedef long long              ffi_sarg;
+#else
+typedef unsigned long          ffi_arg;
+typedef signed long            ffi_sarg;
+#endif
+#endif
+
+typedef enum ffi_abi {
+#if defined(X86_WIN64)
+  FFI_FIRST_ABI = 0,
+  FFI_WIN64,            /* sizeof(long double) == 8  - microsoft compilers */
+  FFI_GNUW64,           /* sizeof(long double) == 16 - GNU compilers */
+  FFI_LAST_ABI,
+#ifdef __GNUC__
+  FFI_DEFAULT_ABI = FFI_GNUW64
+#else
+  FFI_DEFAULT_ABI = FFI_WIN64
+#endif
+
+#elif defined(X86_64) || (defined (__x86_64__) && defined (X86_DARWIN))
+  FFI_FIRST_ABI = 1,
+  FFI_UNIX64,
+  FFI_WIN64,
+  FFI_EFI64 = FFI_WIN64,
+  FFI_GNUW64,
+  FFI_LAST_ABI,
+  FFI_DEFAULT_ABI = FFI_UNIX64
+
+#elif defined(X86_WIN32)
+  FFI_FIRST_ABI = 0,
+  FFI_SYSV      = 1,
+  FFI_STDCALL   = 2,
+  FFI_THISCALL  = 3,
+  FFI_FASTCALL  = 4,
+  FFI_MS_CDECL  = 5,
+  FFI_PASCAL    = 6,
+  FFI_REGISTER  = 7,
+  FFI_LAST_ABI,
+  FFI_DEFAULT_ABI = FFI_MS_CDECL
+#else
+  FFI_FIRST_ABI = 0,
+  FFI_SYSV      = 1,
+  FFI_THISCALL  = 3,
+  FFI_FASTCALL  = 4,
+  FFI_STDCALL   = 5,
+  FFI_PASCAL    = 6,
+  FFI_REGISTER  = 7,
+  FFI_MS_CDECL  = 8,
+  FFI_LAST_ABI,
+  FFI_DEFAULT_ABI = FFI_SYSV
+#endif
+} ffi_abi;
+#endif
+
+/* ---- Definitions for closures ----------------------------------------- */
+
+#define FFI_CLOSURES 1
+#define FFI_GO_CLOSURES 1
+
+#define FFI_TYPE_SMALL_STRUCT_1B (FFI_TYPE_LAST + 1)
+#define FFI_TYPE_SMALL_STRUCT_2B (FFI_TYPE_LAST + 2)
+#define FFI_TYPE_SMALL_STRUCT_4B (FFI_TYPE_LAST + 3)
+#define FFI_TYPE_MS_STRUCT       (FFI_TYPE_LAST + 4)
+
+#if defined (X86_64) || defined(X86_WIN64) \
+    || (defined (__x86_64__) && defined (X86_DARWIN))
+/* 4 bytes of ENDBR64 + 7 bytes of LEA + 6 bytes of JMP + 7 bytes of NOP
+   + 8 bytes of pointer.  */
+# define FFI_TRAMPOLINE_SIZE 32
+# define FFI_NATIVE_RAW_API 0
+#else
+/* 4 bytes of ENDBR32 + 5 bytes of MOV + 5 bytes of JMP + 2 unused
+   bytes.  */
+# define FFI_TRAMPOLINE_SIZE 16
+# define FFI_NATIVE_RAW_API 1  /* x86 has native raw api support */
+#endif
+
+#if !defined(GENERATE_LIBFFI_MAP) && defined(__CET__)
+# include <cet.h>
+# if (__CET__ & 1) != 0
+#   define ENDBR_PRESENT
+# endif
+# define _CET_NOTRACK notrack
+#else
+# define _CET_ENDBR
+# define _CET_NOTRACK
+#endif
+
+#endif

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/about.json

@@ -0,0 +1,133 @@
+{
+  "channels": [
+    "https://repo.anaconda.com/pkgs/main"
+  ],
+  "conda_build_version": "24.1.2",
+  "conda_version": "24.1.2",
+  "description": "The libffi library provides a portable, high level programming interface\nto various calling conventions. This allows a programmer to call any\nfunction specified by a call interface description at run-time.\n",
+  "dev_url": "https://github.com/libffi/libffi",
+  "doc_url": "https://sourceware.org/libffi/",
+  "env_vars": {
+    "CIO_TEST": "<not set>"
+  },
+  "extra": {
+    "copy_test_source_files": true,
+    "final": true,
+    "flow_run_id": "9d85cb11-b977-4c5d-afe8-1f4416fc0019",
+    "recipe-maintainers": [
+      "stefan-balke",
+      "scopatz",
+      "isuruf"
+    ],
+    "remote_url": "git@github.com:AnacondaRecipes/libffi-feedstock.git",
+    "sha": "d17938611be89ed8fc328d1fd8701795d5b7ad9d"
+  },
+  "home": "https://sourceware.org/libffi/",
+  "identifiers": [],
+  "keywords": [],
+  "license": "MIT",
+  "license_family": "MIT",
+  "license_file": "LICENSE",
+  "root_pkgs": [
+    "_libgcc_mutex 0.1 main",
+    "_openmp_mutex 5.1 1_gnu",
+    "archspec 0.2.1 pyhd3eb1b0_0",
+    "boltons 23.0.0 py39h06a4308_0",
+    "brotli-python 1.0.9 py39h6a678d5_7",
+    "bzip2 1.0.8 h7b6447c_0",
+    "c-ares 1.19.1 h5eee18b_0",
+    "charset-normalizer 2.0.4 pyhd3eb1b0_0",
+    "conda-content-trust 0.2.0 py39h06a4308_0",
+    "conda-package-handling 2.2.0 py39h06a4308_0",
+    "conda-package-streaming 0.9.0 py39h06a4308_0",
+    "fmt 9.1.0 hdb19cb5_0",
+    "icu 73.1 h6a678d5_0",
+    "idna 3.4 py39h06a4308_0",
+    "jsonpatch 1.32 pyhd3eb1b0_0",
+    "jsonpointer 2.1 pyhd3eb1b0_0",
+    "krb5 1.20.1 h143b758_1",
+    "ld_impl_linux-64 2.38 h1181459_1",
+    "libarchive 3.6.2 h6ac8c49_2",
+    "libev 4.33 h7f8727e_1",
+    "libffi 3.4.4 h6a678d5_0",
+    "libgcc-ng 11.2.0 h1234567_1",
+    "libgomp 11.2.0 h1234567_1",
+    "libnghttp2 1.57.0 h2d74bed_0",
+    "libsolv 0.7.24 he621ea3_0",
+    "libssh2 1.10.0 hdbd6064_2",
+    "libstdcxx-ng 11.2.0 h1234567_1",
+    "libxml2 2.10.4 hf1b16e4_1",
+    "lz4-c 1.9.4 h6a678d5_0",
+    "ncurses 6.4 h6a678d5_0",
+    "packaging 23.1 py39h06a4308_0",
+    "pcre2 10.42 hebb0a14_0",
+    "pluggy 1.0.0 py39h06a4308_1",
+    "pybind11-abi 4 hd3eb1b0_1",
+    "pycosat 0.6.6 py39h5eee18b_0",
+    "pycparser 2.21 pyhd3eb1b0_0",
+    "pysocks 1.7.1 py39h06a4308_0",
+    "python 3.9.18 h955ad1f_0",
+    "readline 8.2 h5eee18b_0",
+    "reproc 14.2.4 h295c915_1",
+    "reproc-cpp 14.2.4 h295c915_1",
+    "ruamel.yaml 0.17.21 py39h5eee18b_0",
+    "ruamel.yaml.clib 0.2.6 py39h5eee18b_1",
+    "sqlite 3.41.2 h5eee18b_0",
+    "tk 8.6.12 h1ccaba5_0",
+    "tqdm 4.65.0 py39hb070fc8_0",
+    "wheel 0.41.2 py39h06a4308_0",
+    "yaml-cpp 0.8.0 h6a678d5_0",
+    "zlib 1.2.13 h5eee18b_0",
+    "zstandard 0.19.0 py39h5eee18b_0",
+    "zstd 1.5.5 hc292b87_0",
+    "attrs 23.1.0 py39h06a4308_0",
+    "beautifulsoup4 4.12.2 py39h06a4308_0",
+    "ca-certificates 2023.12.12 h06a4308_0",
+    "certifi 2024.2.2 py39h06a4308_0",
+    "cffi 1.16.0 py39h5eee18b_0",
+    "chardet 4.0.0 py39h06a4308_1003",
+    "click 8.1.7 py39h06a4308_0",
+    "conda 24.1.2 py39h06a4308_0",
+    "conda-build 24.1.2 py39h06a4308_0",
+    "conda-index 0.4.0 pyhd3eb1b0_0",
+    "conda-libmamba-solver 24.1.0 pyhd3eb1b0_0",
+    "cryptography 42.0.2 py39hdda0065_0",
+    "distro 1.8.0 py39h06a4308_0",
+    "filelock 3.13.1 py39h06a4308_0",
+    "jinja2 3.1.3 py39h06a4308_0",
+    "jsonschema 4.19.2 py39h06a4308_0",
+    "jsonschema-specifications 2023.7.1 py39h06a4308_0",
+    "libcurl 8.5.0 h251f7ec_0",
+    "libedit 3.1.20230828 h5eee18b_0",
+    "liblief 0.12.3 h6a678d5_0",
+    "libmamba 1.5.6 haf1ee3a_0",
+    "libmambapy 1.5.6 py39h2dafd23_0",
+    "markupsafe 2.1.3 py39h5eee18b_0",
+    "menuinst 2.0.2 py39h06a4308_0",
+    "more-itertools 10.1.0 py39h06a4308_0",
+    "openssl 3.0.13 h7f8727e_0",
+    "patch 2.7.6 h7b6447c_1001",
+    "patchelf 0.17.2 h6a678d5_0",
+    "pip 23.3.1 py39h06a4308_0",
+    "pkginfo 1.9.6 py39h06a4308_0",
+    "platformdirs 3.10.0 py39h06a4308_0",
+    "psutil 5.9.0 py39h5eee18b_0",
+    "py-lief 0.12.3 py39h6a678d5_0",
+    "pyopenssl 24.0.0 py39h06a4308_0",
+    "python-libarchive-c 2.9 pyhd3eb1b0_1",
+    "pytz 2023.3.post1 py39h06a4308_0",
+    "pyyaml 6.0.1 py39h5eee18b_0",
+    "referencing 0.30.2 py39h06a4308_0",
+    "requests 2.31.0 py39h06a4308_1",
+    "rpds-py 0.10.6 py39hb02cf49_0",
+    "setuptools 68.2.2 py39h06a4308_0",
+    "soupsieve 2.5 py39h06a4308_0",
+    "tomli 2.0.1 py39h06a4308_0",
+    "tzdata 2023d h04d1e81_0",
+    "urllib3 2.1.0 py39h06a4308_1",
+    "xz 5.4.5 h5eee18b_0",
+    "yaml 0.2.5 h7b6447c_0"
+  ],
+  "summary": "A Portable Foreign Function Interface Library",
+  "tags": []
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/files

@@ -0,0 +1,15 @@
+include/ffi.h
+include/ffitarget.h
+lib/libffi.7.so
+lib/libffi.8.so
+lib/libffi.a
+lib/libffi.so
+lib/libffi.so.7
+lib/libffi.so.8
+lib/libffi.so.8.1.2
+lib/pkgconfig/libffi.pc
+share/info/libffi.info
+share/man/man3/ffi.3
+share/man/man3/ffi_call.3
+share/man/man3/ffi_prep_cif.3
+share/man/man3/ffi_prep_cif_var.3

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/has_prefix

@@ -0,0 +1 @@
+/croot/libffi_1714483243560/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_ text lib/pkgconfig/libffi.pc

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/hash_input.json

@@ -0,0 +1,8 @@
+{
+  "c_compiler_version": "11.2.0",
+  "cxx_compiler_version": "11.2.0",
+  "cxx_compiler": "gxx",
+  "c_compiler": "gcc",
+  "target_platform": "linux-64",
+  "channel_targets": "defaults"
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/index.json

@@ -0,0 +1,16 @@
+{
+  "arch": "x86_64",
+  "build": "h6a678d5_1",
+  "build_number": 1,
+  "depends": [
+    "libgcc-ng >=11.2.0",
+    "libstdcxx-ng >=11.2.0"
+  ],
+  "license": "MIT",
+  "license_family": "MIT",
+  "name": "libffi",
+  "platform": "linux",
+  "subdir": "linux-64",
+  "timestamp": 1714483282916,
+  "version": "3.4.4"
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/licenses/LICENSE

@@ -0,0 +1,21 @@
+libffi - Copyright (c) 1996-2022  Anthony Green, Red Hat, Inc and others.
+See source files for details.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+``Software''), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/paths.json

@@ -0,0 +1,97 @@
+{
+  "paths": [
+    {
+      "_path": "include/ffi.h",
+      "path_type": "hardlink",
+      "sha256": "f49fc7045d930af653d73aa480b645b296399a6205002215894d90de4de8355a",
+      "size_in_bytes": 14287
+    },
+    {
+      "_path": "include/ffitarget.h",
+      "path_type": "hardlink",
+      "sha256": "45e4fd2585aaed711e4fa3d1377b70c8e54dcdc56bdf402fa23a8816d19cc58a",
+      "size_in_bytes": 4928
+    },
+    {
+      "_path": "lib/libffi.7.so",
+      "path_type": "softlink",
+      "sha256": "a5d54aeb8ed2fd5e0ccf9d38b28cad6dec76517f69224a5d9687c1970b57b194",
+      "size_in_bytes": 72144
+    },
+    {
+      "_path": "lib/libffi.8.so",
+      "path_type": "softlink",
+      "sha256": "a5d54aeb8ed2fd5e0ccf9d38b28cad6dec76517f69224a5d9687c1970b57b194",
+      "size_in_bytes": 72144
+    },
+    {
+      "_path": "lib/libffi.a",
+      "path_type": "hardlink",
+      "sha256": "66e22d52480d4a11234ee038fe8929c1fdeea490a344260ed10711dd900059d7",
+      "size_in_bytes": 97758
+    },
+    {
+      "_path": "lib/libffi.so",
+      "path_type": "softlink",
+      "sha256": "a5d54aeb8ed2fd5e0ccf9d38b28cad6dec76517f69224a5d9687c1970b57b194",
+      "size_in_bytes": 72144
+    },
+    {
+      "_path": "lib/libffi.so.7",
+      "path_type": "softlink",
+      "sha256": "a5d54aeb8ed2fd5e0ccf9d38b28cad6dec76517f69224a5d9687c1970b57b194",
+      "size_in_bytes": 72144
+    },
+    {
+      "_path": "lib/libffi.so.8",
+      "path_type": "softlink",
+      "sha256": "a5d54aeb8ed2fd5e0ccf9d38b28cad6dec76517f69224a5d9687c1970b57b194",
+      "size_in_bytes": 72144
+    },
+    {
+      "_path": "lib/libffi.so.8.1.2",
+      "path_type": "hardlink",
+      "sha256": "a5d54aeb8ed2fd5e0ccf9d38b28cad6dec76517f69224a5d9687c1970b57b194",
+      "size_in_bytes": 72144
+    },
+    {
+      "_path": "lib/pkgconfig/libffi.pc",
+      "file_mode": "text",
+      "path_type": "hardlink",
+      "prefix_placeholder": "/croot/libffi_1714483243560/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_",
+      "sha256": "d42c74b8e17b72244a609b67b6f23d18da75e961f35ae11a8be0f205daee22b4",
+      "size_in_bytes": 756
+    },
+    {
+      "_path": "share/info/libffi.info",
+      "path_type": "hardlink",
+      "sha256": "f7481e5e3817a91d6c746b69f0b2708470b802bb2a6834b9a82e9f71b661fb62",
+      "size_in_bytes": 38202
+    },
+    {
+      "_path": "share/man/man3/ffi.3",
+      "path_type": "hardlink",
+      "sha256": "aa4730e114c305943a2226a524ed8447dc6b66a184523999868e5433c2c9de74",
+      "size_in_bytes": 850
+    },
+    {
+      "_path": "share/man/man3/ffi_call.3",
+      "path_type": "hardlink",
+      "sha256": "2817ce7b78cb737d7b85b18b45899470f5f565f990d056d3d8cfabf6d779477f",
+      "size_in_bytes": 2333
+    },
+    {
+      "_path": "share/man/man3/ffi_prep_cif.3",
+      "path_type": "hardlink",
+      "sha256": "f60c5bb9d04b55988da13511a2c3edfa0f39fb6f51abfb8ac24d0b161c4169c0",
+      "size_in_bytes": 1158
+    },
+    {
+      "_path": "share/man/man3/ffi_prep_cif_var.3",
+      "path_type": "hardlink",
+      "sha256": "9365685252f33f13627c9303bc01883b764227132069260c19e94100ff442a51",
+      "size_in_bytes": 1321
+    }
+  ],
+  "paths_version": 1
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/0001-arm64-changes-from-v3.3-patch.patch

@@ -0,0 +1,213 @@
+From a6ef415fa95661b67017f1bdc32d8f98db7d9c44 Mon Sep 17 00:00:00 2001
+From: Daniel Holth <dholth@anaconda.com>
+Date: Fri, 27 Aug 2021 15:55:36 -0400
+Subject: [PATCH] arm64 changes merged from v3.3 arm64-changes patch
+
+---
+ src/aarch64/ffi.c | 29 +++++++++++++++++---
+ src/closures.c    | 67 ++++++++++++++++++++++++++++++++++++++++-------
+ src/x86/ffi64.c   |  6 +++++
+ 3 files changed, 89 insertions(+), 13 deletions(-)
+
+diff --git a/src/aarch64/ffi.c b/src/aarch64/ffi.c
+index 6544ac0..3f936d3 100644
+--- a/src/aarch64/ffi.c
++++ b/src/aarch64/ffi.c
+@@ -715,12 +715,13 @@ ffi_call_int (ffi_cif *cif, void (*fn)(void), void *orig_rvalue,
+ 		state.ngrn = N_X_ARG_REG;
+ 		/* Note that the default abi extends each argument
+ 		   to a full 64-bit slot, while the iOS abi allocates
+-		   only enough space. */
++		   only enough space, except for variadic arguments. */
+ #ifdef __APPLE__
+-		memcpy(d, a, s);
+-#else
+-		*(ffi_arg *)d = ext;
++		if (!state.allocating_variadic)
++		  memcpy(d, a, s);
++		else
+ #endif
++		  *(ffi_arg *)d = ext;
+ 	      }
+ 	  }
+ 	  break;
+@@ -867,7 +868,11 @@ ffi_prep_closure_loc (ffi_closure *closure,
+ #  ifdef HAVE_PTRAUTH
+   codeloc = ptrauth_auth_data(codeloc, ptrauth_key_function_pointer, 0);
+ #  endif
++#  ifdef FFI_TRAMPOLINE_WHOLE_DYLIB
++  void **config = (void **)((uint8_t *)codeloc - 2*PAGE_MAX_SIZE);
++#  else
+   void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE);
++#  endif
+   config[0] = closure;
+   config[1] = start;
+ # endif
+@@ -920,6 +925,22 @@ out:
+   return FFI_OK;
+ }
+ 
++ffi_closure *
++ffi_find_closure_for_code(void *codeloc)
++{
++#if FFI_EXEC_TRAMPOLINE_TABLE
++#  ifdef FFI_TRAMPOLINE_WHOLE_DYLIB
++    void **config = (void **)((uint8_t *)codeloc - 2*PAGE_MAX_SIZE);
++#  else
++    void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE);
++#  endif
++    return config[0];
++#else
++    return (ffi_closure*)codeloc;
++#endif
++}
++ffi_closure *ffi_find_closure_for_code_np(void *codeloc) { return ffi_find_closure_for_code(codeloc); }  /* Apple renamed this entry ... */
++
+ #ifdef FFI_GO_CLOSURES
+ extern void ffi_go_closure_SYSV (void) FFI_HIDDEN;
+ extern void ffi_go_closure_SYSV_V (void) FFI_HIDDEN;
+diff --git a/src/closures.c b/src/closures.c
+index 9aafbec..af1c3b8 100644
+--- a/src/closures.c
++++ b/src/closures.c
+@@ -168,7 +168,13 @@ ffi_tramp_is_present (__attribute__((unused)) void *ptr)
+ #include <stdio.h>
+ #include <stdlib.h>
+ 
++#ifdef FFI_TRAMPOLINE_WHOLE_DYLIB
++#include <assert.h>
++#include <dispatch/dispatch.h>
++#include <dlfcn.h>
++#else
+ extern void *ffi_closure_trampoline_table_page;
++#endif
+ 
+ typedef struct ffi_trampoline_table ffi_trampoline_table;
+ typedef struct ffi_trampoline_table_entry ffi_trampoline_table_entry;
+@@ -196,6 +202,21 @@ struct ffi_trampoline_table_entry
+ /* Total number of trampolines that fit in one trampoline table */
+ #define FFI_TRAMPOLINE_COUNT (PAGE_MAX_SIZE / FFI_TRAMPOLINE_SIZE)
+ 
++/* The trampoline dylib has one page for the MACHO_HEADER and one page for the
++ * trampolines. iOS 12.0 and later, and macOS on Apple Silicon require that
++ * the entire dylib needs to be remapped as a unit.
++ *
++ * arm (legacy): Allocate two pages -- a config page and a placeholder for the trampolines
++ * arm64 (modern): Allocate three pages -- a config page and two placeholders for the trampoline dylib
++ */
++#ifdef FFI_TRAMPOLINE_WHOLE_DYLIB
++#define FFI_TRAMPOLINE_ALLOCATION_PAGE_COUNT 3
++#define FFI_TRAMPOLINE_PAGE_SEGMENT_OFFSET PAGE_MAX_SIZE
++#else
++#define FFI_TRAMPOLINE_ALLOCATION_PAGE_COUNT 2
++#define FFI_TRAMPOLINE_PAGE_SEGMENT_OFFSET 0
++#endif
++
+ static pthread_mutex_t ffi_trampoline_lock = PTHREAD_MUTEX_INITIALIZER;
+ static ffi_trampoline_table *ffi_trampoline_tables = NULL;
+ 
+@@ -211,35 +232,63 @@ ffi_trampoline_table_alloc (void)
+   kern_return_t kt;
+   uint16_t i;
+ 
+-  /* Allocate two pages -- a config page and a placeholder page */
+   config_page = 0x0;
+-  kt = vm_allocate (mach_task_self (), &config_page, PAGE_MAX_SIZE * 2,
++  /* The entire allocation is:
++   *    config_page
++   *    trampoline_segment
++   *
++   * trampoline_segment is:
++   *    trampoline dylib mach-o header (if FFI_TRAMPOLINE_WHOLE_DYLIB)
++   *    trampoline page
++   */
++  kt = vm_allocate (mach_task_self (), &config_page, FFI_TRAMPOLINE_ALLOCATION_PAGE_COUNT * PAGE_MAX_SIZE,
+ 		    VM_FLAGS_ANYWHERE);
+   if (kt != KERN_SUCCESS)
+     return NULL;
+ 
+-  /* Remap the trampoline table on top of the placeholder page */
+-  trampoline_page = config_page + PAGE_MAX_SIZE;
++  static void *trampoline_table_page;
++
++#ifdef FFI_TRAMPOLINE_WHOLE_DYLIB
++  static dispatch_once_t trampoline_template_init_once;
++
++  dispatch_once(&trampoline_template_init_once, ^{
++    void * const trampoline_handle = dlopen("/usr/lib/libffi-trampolines.dylib", RTLD_NOW | RTLD_LOCAL | RTLD_FIRST);
++    assert(trampoline_handle);
++
++    trampoline_table_page = dlsym(trampoline_handle, "ffi_closure_trampoline_table_page");
++    assert(trampoline_table_page);
++  });
++#else
++  trampoline_table_page = &ffi_closure_trampoline_table_page;
++#endif
+ 
+ #ifdef HAVE_PTRAUTH
+-  trampoline_page_template = (vm_address_t)(uintptr_t)ptrauth_auth_data((void *)&ffi_closure_trampoline_table_page, ptrauth_key_function_pointer, 0);
++  trampoline_page_template = (uintptr_t)ptrauth_auth_data(trampoline_table_page, ptrauth_key_function_pointer, 0);
+ #else
+-  trampoline_page_template = (vm_address_t)&ffi_closure_trampoline_table_page;
++  trampoline_page_template = (uintptr_t)trampoline_table_page;
+ #endif
+ 
+ #ifdef __arm__
+   /* ffi_closure_trampoline_table_page can be thumb-biased on some ARM archs */
+   trampoline_page_template &= ~1UL;
+ #endif
+-  kt = vm_remap (mach_task_self (), &trampoline_page, PAGE_MAX_SIZE, 0x0,
+-		 VM_FLAGS_OVERWRITE, mach_task_self (), trampoline_page_template,
++
++  vm_address_t trampoline_segment_template = trampoline_page_template - FFI_TRAMPOLINE_PAGE_SEGMENT_OFFSET;
++  vm_size_t trampoline_segment_size = (FFI_TRAMPOLINE_ALLOCATION_PAGE_COUNT - 1) * PAGE_MAX_SIZE;
++
++  /* Remap the trampoline table on top of the placeholder page */
++  vm_address_t trampoline_segment = config_page + PAGE_MAX_SIZE;
++  kt = vm_remap (mach_task_self(), &trampoline_segment, trampoline_segment_size, 0x0,
++		 VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE, mach_task_self(), trampoline_segment_template,
+ 		 FALSE, &cur_prot, &max_prot, VM_INHERIT_SHARE);
+   if (kt != KERN_SUCCESS)
+     {
+-      vm_deallocate (mach_task_self (), config_page, PAGE_MAX_SIZE * 2);
++      vm_deallocate (mach_task_self (), config_page, FFI_TRAMPOLINE_ALLOCATION_PAGE_COUNT * PAGE_MAX_SIZE);
+       return NULL;
+     }
+ 
++  trampoline_page = trampoline_segment + FFI_TRAMPOLINE_PAGE_SEGMENT_OFFSET;
++
+   if (!(cur_prot & VM_PROT_EXECUTE))
+     {
+       /* If VM_PROT_EXECUTE isn't set on the remapped trampoline page, set it */
+       kt = vm_protect (mach_task_self (), trampoline_page, PAGE_MAX_SIZE,
+          FALSE, cur_prot | VM_PROT_EXECUTE);
+       if (kt != KERN_SUCCESS)
+         {
+           vm_deallocate (mach_task_self (), config_page, PAGE_MAX_SIZE * 2);
+           return NULL;
+         }
+     }
+
+   /* We have valid trampoline and config pages */
+   table = calloc (1, sizeof (ffi_trampoline_table));
+   table->free_count = FFI_TRAMPOLINE_COUNT;
+diff --git a/src/x86/ffi64.c b/src/x86/ffi64.c
+index 6a8e37f..a3d51bc 100644
+--- a/src/x86/ffi64.c
++++ b/src/x86/ffi64.c
+@@ -809,6 +809,12 @@ out:
+   return FFI_OK;
+ }
+ 
++ffi_closure *
++ffi_find_closure_for_code(void *code)
++{
++    return (ffi_closure *) code;
++}
++ ffi_closure *ffi_find_closure_for_code_np(void *code) { return ffi_find_closure_for_code(code); }  /* Apple renamed ... */
+ int FFI_HIDDEN
+ ffi_closure_unix64_inner(ffi_cif *cif,
+ 			 void (*fun)(ffi_cif*, void*, void**, void*),
+-- 
+2.32.0
+

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/0002-Don-t-define-FFI_COMPLEX_TYPEDEF-ifndef-FFI_TARGET_H.patch

@@ -0,0 +1,33 @@
+From 77a2d361b38c957700a79b79dd4002eb9b638877 Mon Sep 17 00:00:00 2001
+From: Ray Donnelly <mingw.android@gmail.com>
+Date: Fri, 3 Jun 2016 14:26:07 +0100
+Subject: [PATCH 2/3] Don't define FFI_COMPLEX_TYPEDEF ifndef
+ FFI_TARGET_HAS_COMPLEX_TYPE
+
+---
+ src/types.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/src/types.c b/src/types.c
+index 7e80aec..e4b024c 100644
+--- a/src/types.c
++++ b/src/types.c
+@@ -45,6 +45,7 @@ maybe_const ffi_type ffi_type_##name = {	\
+   id, NULL					\
+ }
+ 
++#ifdef FFI_TARGET_HAS_COMPLEX_TYPE
+ #define FFI_COMPLEX_TYPEDEF(name, type, maybe_const)	\
+ static ffi_type *ffi_elements_complex_##name [2] = {	\
+ 	(ffi_type *)(&ffi_type_##name), NULL		\
+@@ -60,6 +61,7 @@ maybe_const ffi_type ffi_type_complex_##name = {	\
+   FFI_TYPE_COMPLEX,					\
+   (ffi_type **)ffi_elements_complex_##name		\
+ }
++#endif
+ 
+ /* Size and alignment are fake here. They must not be 0. */
+ FFI_EXTERN const ffi_type ffi_type_void = {
+-- 
+2.8.2
+

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/0004-LIBFFI_CLOSURE.patch

@@ -0,0 +1,84 @@
+Index: libffi-3.4.4/libffi.map.in
+===================================================================
+--- libffi-3.4.4.orig/libffi.map.in
++++ libffi-3.4.4/libffi.map.in
+@@ -74,3 +74,79 @@ LIBFFI_GO_CLOSURE_8.0 {
+ 	ffi_prep_go_closure;
+ } LIBFFI_CLOSURE_8.0;
+ #endif
++
++/* These version numbers correspond to the libtool-version abi numbers,
++   not to the libffi release numbers.  */
++
++LIBFFI_BASE_7.0 {
++  global:
++	/* Exported data variables.  */
++	ffi_type_void;
++	ffi_type_uint8;
++	ffi_type_sint8;
++	ffi_type_uint16;
++	ffi_type_sint16;
++	ffi_type_uint32;
++	ffi_type_sint32;
++	ffi_type_uint64;
++	ffi_type_sint64;
++	ffi_type_float;
++	ffi_type_double;
++	ffi_type_longdouble;
++	ffi_type_pointer;
++
++	/* Exported functions.  */
++	ffi_call;
++	ffi_prep_cif;
++	ffi_prep_cif_var;
++
++	ffi_raw_call;
++	ffi_ptrarray_to_raw;
++	ffi_raw_to_ptrarray;
++	ffi_raw_size;
++
++	ffi_java_raw_call;
++	ffi_java_ptrarray_to_raw;
++	ffi_java_raw_to_ptrarray;
++	ffi_java_raw_size;
++
++  local:
++	*;
++};
++
++LIBFFI_BASE_7.1 {
++  global:
++	ffi_get_struct_offsets;
++} LIBFFI_BASE_7.0;
++
++#ifdef FFI_TARGET_HAS_COMPLEX_TYPE
++LIBFFI_COMPLEX_7.0 {
++  global:
++	/* Exported data variables.  */
++	ffi_type_complex_float;
++	ffi_type_complex_double;
++	ffi_type_complex_longdouble;
++} LIBFFI_BASE_7.0;
++#endif
++
++#if FFI_CLOSURES
++LIBFFI_CLOSURE_7.0 {
++  global:
++	ffi_closure_alloc;
++	ffi_closure_free;
++	ffi_prep_closure;
++	ffi_prep_closure_loc;
++	ffi_prep_raw_closure;
++	ffi_prep_raw_closure_loc;
++	ffi_prep_java_raw_closure;
++	ffi_prep_java_raw_closure_loc;
++} LIBFFI_BASE_7.0;
++#endif
++
++#if FFI_GO_CLOSURES
++LIBFFI_GO_CLOSURE_7.0 {
++  global:
++	ffi_call_go;
++	ffi_prep_go_closure;
++} LIBFFI_CLOSURE_7.0;
++#endif

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/bld.bat

@@ -0,0 +1,34 @@
+if "%ARCH%" == "64" (
+  set ARCH="x64"
+) else (
+  set ARCH="Win32"
+)
+
+mkdir buildd
+cd buildd
+cmake -G "NMake Makefiles" ^
+  -D CMAKE_BUILD_TYPE=Release ^
+  -D CMAKE_PREFIX_PATH=%LIBRARY_PREFIX% ^
+  -D CMAKE_INSTALL_PREFIX:PATH=%LIBRARY_PREFIX% ^
+  -D BUILD_SHARED_LIBS:BOOL=ON ^
+  -D VERSION=%PKG_VERSION% ^
+  ..
+
+echo "configured ..."
+
+cmake --build . --config Release
+
+echo "built ..."
+
+cmake --build . --target install --config Release
+
+if errorlevel 1 exit 1
+
+copy %LIBRARY_LIB%\ffi.lib %LIBRARY_LIB%\libffi.lib
+copy %LIBRARY_LIB%\ffi.lib %LIBRARY_LIB%\libffi.dll.lib
+copy %LIBRARY_PREFIX%\bin\ffi.dll %LIBRARY_PREFIX%\bin\ffi-8.dll
+:: ffi-8 is backward compatible to ffi-7
+copy %LIBRARY_PREFIX%\bin\ffi.dll %LIBRARY_PREFIX%\bin\ffi-7.dll
+
+exit 0
+

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/build.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+set -ex
+
+cd $SRC_DIR
+
+# work-a-round for cyclic dependencies on OSX
+if [[ $target_platform == osx-* ]]; then
+  conda create -p $SRC_DIR/compilers clang_${target_platform} clangxx_${target_platform} --yes --quiet
+  cp -fr compilers/* $BUILD_PREFIX/. 2>/dev/null || true
+  # do manual activation ...
+  . $BUILD_PREFIX/etc/conda/activate.d/activate_clang_${target_platform}.sh
+  . $BUILD_PREFIX/etc/conda/activate.d/activate_clangxx_${target_platform}.sh
+fi
+
+export CFLAGS="${CFLAGS//-fvisibility=+([! ])/}"
+export CXXFLAGS="${CXXFLAGS//-fvisibility=+([! ])/}"
+
+configure_args=(
+    --disable-debug
+    --disable-dependency-tracking
+    --prefix="${PREFIX}"
+    --includedir="${PREFIX}/include"
+)
+
+configure_args+=(--build=$BUILD --host=$HOST)
+
+if [[ "$target_platform" == osx-* ]]; then
+  export CFLAGS="${CFLAGS} -Wno-deprecated-declarations"
+  export CXXFLAGS="${CXXFLAGS} -Wno-deprecated-declarations"
+  export CPP="${CC} -E"
+  export CXXCPP="${CXX} -E"
+else
+ autoreconf -vfi
+fi
+
+if [[ "$target_platform" == linux* ]]; then
+  # this changes the install dir from ${PREFIX}/lib64 to ${PREFIX}/lib
+  sed -i 's:@toolexeclibdir@:$(libdir):g' Makefile.in */Makefile.in
+  sed -i 's:@toolexeclibdir@:${libdir}:g' libffi.pc.in
+fi
+
+./configure "${configure_args[@]}" || { cat config.log; exit 1;}
+
+make -j${CPU_COUNT} ${VERBOSE_AT}
+make check
+make install
+
+if [[ $target_platform == osx-* ]]; then
+  # do manual deactivation ...
+  . $BUILD_PREFIX/etc/conda/deactivate.d/deactivate_clang_${target_platform}.sh
+  . $BUILD_PREFIX/etc/conda/deactivate.d/deactivate_clangxx_${target_platform}.sh
+fi
+
+# This overlaps with libgcc-ng:
+rm -rf ${PREFIX}/share/info/dir
+
+# Make sure we provide old variant.  As in 3.4 no API change was introduced in coparison to 3.3
+# we will go with the assumption of being backward compatible.
+pushd $PREFIX/lib
+# make sure we address also <lib>.so<.number>, and don't produce dead links
+if [[ -f libffi${SHLIB_EXT}.8 ]]; then
+  ln -s libffi${SHLIB_EXT}.8 libffi${SHLIB_EXT}.7
+  if [[ ! -f libffi.8{SHLIB_EXT} ]]; then
+    ln -s libffi${SHLIB_EXT}.8 libffi.8${SHLIB_EXT}
+  fi
+fi
+ln -s -f libffi.8${SHLIB_EXT} libffi.7${SHLIB_EXT}
+popd
+

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/conda_build_config.yaml

@@ -0,0 +1,101 @@
+VERBOSE_AT: V=1
+VERBOSE_CM: VERBOSE=1
+apr: 1.6.3
+blas_impl: openblas
+boost: '1.82'
+boost_cpp: '1.82'
+bzip2: '1.0'
+c_compiler: gcc
+c_compiler_version: 11.2.0
+cairo: '1.16'
+channel_targets: defaults
+clang_variant: clang
+cpu_optimization_target: nocona
+cran_mirror: https://mran.microsoft.com/snapshot/2018-01-01
+cxx_compiler: gxx
+cxx_compiler_version: 11.2.0
+cyrus_sasl: 2.1.28
+dbus: '1'
+expat: '2'
+extend_keys:
+- extend_keys
+- ignore_build_only_deps
+- pin_run_as_build
+- ignore_version
+fontconfig: '2.14'
+fortran_compiler: gfortran
+fortran_compiler_version: 11.2.0
+freetype: '2.10'
+g2clib: '1.6'
+geos: 3.8.0
+giflib: '5'
+glib: '2'
+gmp: '6.1'
+gnu: 2.12.2
+gst_plugins_base: '1.14'
+gstreamer: '1.14'
+harfbuzz: 4.3.0
+hdf4: '4.2'
+hdf5: 1.12.1
+hdfeos2: '2.20'
+hdfeos5: '5.1'
+icu: '73'
+ignore_build_only_deps:
+- numpy
+- python
+jpeg: '9'
+libcurl: 8.1.1
+libdap4: '3.19'
+libffi: '3.4'
+libgd: 2.3.3
+libgdal: 3.6.2
+libgsasl: '1.10'
+libkml: '1.3'
+libnetcdf: '4.8'
+libpng: '1.6'
+libprotobuf: 3.20.3
+libtiff: '4.2'
+libwebp: 1.3.2
+libxml2: '2.10'
+libxslt: '1.1'
+llvm_variant: llvm
+lua: '5'
+lzo: '2'
+mkl: 2023.*
+mpfr: '4'
+numpy: '1.21'
+openblas: 0.3.21
+openjpeg: '2.3'
+openssl: '3.0'
+perl: '5.34'
+pin_run_as_build:
+  python:
+    max_pin: x.x
+    min_pin: x.x
+  r-base:
+    max_pin: x.x
+    min_pin: x.x
+  libboost:
+    max_pin: x.x.x
+pixman: '0.40'
+proj: 9.3.1
+proj4: 5.2.0
+python: '3.8'
+python_impl: cpython
+python_implementation: cpython
+r_base: '3.5'
+r_implementation: r-base
+r_version: 3.5.0
+readline: '8.0'
+rust_compiler: rust
+rust_compiler_version: 1.71.1
+serf: 1.3.9
+sqlite: '3'
+target_platform: linux-64
+tk: '8.6'
+xz: '5'
+zip_keys:
+- - python
+  - numpy
+zlib: '1.2'
+zstd: 1.5.2

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/fix_w3264_masm.patch

@@ -0,0 +1,37 @@
+diff --git a/configure_options.cmake b/configure_options.cmake
+index 849231c..ceb6539 100644
+--- a/configure_options.cmake
++++ b/configure_options.cmake
+@@ -79,6 +79,7 @@ elseif(TARGET_PLATFORM STREQUAL X86_64)
+ elseif(TARGET_PLATFORM MATCHES X86.*)
+     if(MSVC)
+         list(APPEND WIN_ASSEMBLY_LIST src/x86/sysv_intel.S)
++        set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
+         enable_language(ASM_MASM)
+     else()
+         list(APPEND SOURCES_LIST src/x86/sysv.S)
+@@ -329,13 +330,17 @@ foreach(ASM_PATH IN LISTS WIN_ASSEMBLY_LIST)
+ 
+     set_source_files_properties("${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm" PROPERTIES GENERATED TRUE)
+ 
+-    add_custom_command(
+-        COMMAND "${CMAKE_ASM_MASM_COMPILER}" /Fo "${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj" "${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm"
+-        DEPENDS ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm
+-        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj
+-        COMMENT "Assembling ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm")
++    if(TARGET_PLATFORM MATCHES X86.*)
++        list(APPEND SOURCES_LIST ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm)
++    else()
++        add_custom_command(
++            COMMAND "${CMAKE_ASM_MASM_COMPILER}" /Fo "${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj" "${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm"
++            DEPENDS ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm
++            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj
++            COMMENT "Assembling ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm")
+ 
+-    set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj PROPERTIES EXTERNAL_OBJECT TRUE)
++        set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj PROPERTIES EXTERNAL_OBJECT TRUE)
+ 
+-    list(APPEND OBJECTS_LIST ${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj)
++        list(APPEND OBJECTS_LIST ${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj)
++    endif()
+ endforeach()

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/meta.yaml

@@ -0,0 +1,96 @@
+# This file created by conda-build 24.1.2
+# meta.yaml template originally from:
+# /feedstock/recipe, last modified Tue Apr 30 13:20:34 2024
+# ------------------------------------------------
+
+package:
+  name: libffi
+  version: 3.4.4
+source:
+  patches:
+    - 0004-LIBFFI_CLOSURE.patch
+  sha256: d66c56ad259a82cf2a9dfc408b32bf5da52371500b84745f7fb8b645712df676
+  url: https://github.com/libffi/libffi/releases/download/v3.4.4/libffi-3.4.4.tar.gz
+build:
+  number: '1'
+  run_exports:
+    - libffi >=3.4,<4.0a0
+  string: h6a678d5_1
+requirements:
+  build:
+    - _libgcc_mutex 0.1 main
+    - _openmp_mutex 5.1 1_gnu
+    - _sysroot_linux-64_curr_repodata_hack 3 haa98f57_10
+    - autoconf 2.71 pl5340h5eee18b_0
+    - automake 1.16.5 pl5340h06a4308_1
+    - binutils_impl_linux-64 2.38 h2a08ee3_1
+    - binutils_linux-64 2.38.0 hc2dff05_0
+    - gcc_impl_linux-64 11.2.0 h1234567_1
+    - gcc_linux-64 11.2.0 h5c386dc_0
+    - gdbm 1.18 hd4cb3f1_4
+    - gettext 0.21.0 h39681ba_1
+    - gxx_impl_linux-64 11.2.0 h1234567_1
+    - gxx_linux-64 11.2.0 hc2dff05_0
+    - icu 73.1 h6a678d5_0
+    - kernel-headers_linux-64 3.10.0 h57e8cba_10
+    - ld_impl_linux-64 2.38 h1181459_1
+    - libgcc-devel_linux-64 11.2.0 h1234567_1
+    - libgcc-ng 11.2.0 h1234567_1
+    - libgomp 11.2.0 h1234567_1
+    - libstdcxx-devel_linux-64 11.2.0 h1234567_1
+    - libstdcxx-ng 11.2.0 h1234567_1
+    - libtool 2.4.6 h6a678d5_1009
+    - libxml2 2.10.4 hfdd30dd_2
+    - m4 1.4.18 h4e445db_0
+    - make 4.2.1 h1bed415_1
+    - ncurses 6.4 h6a678d5_0
+    - patch 2.7.6 h7b6447c_1001
+    - perl 5.34.0 h5eee18b_2
+    - readline 8.2 h5eee18b_0
+    - sed 4.8 h7b6447c_0
+    - sysroot_linux-64 2.17 h57e8cba_10
+    - texinfo 6.8 pl5262h7f8727e_0
+    - xz 5.4.6 h5eee18b_0
+    - zlib 1.2.13 h5eee18b_0
+  host:
+    - _libgcc_mutex 0.1 main
+    - _openmp_mutex 5.1 1_gnu
+    - libgcc-ng 11.2.0 h1234567_1
+    - libgomp 11.2.0 h1234567_1
+    - libstdcxx-ng 11.2.0 h1234567_1
+  run:
+    - libgcc-ng >=11.2.0
+    - libstdcxx-ng >=11.2.0
+test:
+  requires:
+    - gcc_linux-64 11.2.0.*
+    - gxx_linux-64 11.2.0.*
+    - make
+  source_files:
+    - testsuite
+    - testsuite/libffi.bhaible
+about:
+  description: 'The libffi library provides a portable, high level programming interface
+
+    to various calling conventions. This allows a programmer to call any
+
+    function specified by a call interface description at run-time.
+
+    '
+  dev_url: https://github.com/libffi/libffi
+  doc_url: https://sourceware.org/libffi/
+  home: https://sourceware.org/libffi/
+  license: MIT
+  license_family: MIT
+  license_file: LICENSE
+  summary: A Portable Foreign Function Interface Library
+extra:
+  copy_test_source_files: true
+  final: true
+  flow_run_id: 9d85cb11-b977-4c5d-afe8-1f4416fc0019
+  recipe-maintainers:
+    - isuruf
+    - scopatz
+    - stefan-balke
+  remote_url: git@github.com:AnacondaRecipes/libffi-feedstock.git
+  sha: d17938611be89ed8fc328d1fd8701795d5b7ad9d

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/meta.yaml.template

@@ -0,0 +1,72 @@
+{% set version = "3.4.4" %}
+{% set am_version = "1.15" %} # keep synchronized with build.sh
+{% set posix = 'm2-' if win else '' %}
+{% set native = 'm2w64-' if win else '' %}
+
+package:
+  name: libffi
+  version: {{ version }}
+
+source:
+  url: https://github.com/libffi/libffi/releases/download/v{{version}}/libffi-{{version}}.tar.gz
+  sha256: d66c56ad259a82cf2a9dfc408b32bf5da52371500b84745f7fb8b645712df676
+  patches:
+    - 0001-arm64-changes-from-v3.3-patch.patch  # [osx]
+    # Windows-specific:
+    - 0002-Don-t-define-FFI_COMPLEX_TYPEDEF-ifndef-FFI_TARGET_H.patch  # [win]
+    - win_cmake.patch        # [win]
+    - fix_w3264_masm.patch   # [win]
+    - 0004-LIBFFI_CLOSURE.patch  # [linux]
+build:
+  number: 1
+  run_exports:
+    # good history: https://abi-laboratory.pro/tracker/timeline/libffi/
+    - {{ pin_subpackage('libffi', "x.x") }}
+
+requirements:
+  build:
+    - cmake                              # [win]
+    - make                               # [unix]
+    - autoconf                           # [unix]
+    - libtool                            # [unix]
+    - {{ posix }}patch
+    - automake                           # [unix]
+    - {{ posix }}texinfo                 # [unix]
+    - {{ compiler('c') }}                # [not osx]
+    - {{ compiler('cxx') }}              # [not osx]
+    - {{ posix }}sed                     # [unix]
+  host:
+  run:
+
+test:
+  requires:
+    - llvm-tools  # [win]
+    - m2-grep     # [win]
+    - make # [unix]
+    - cmake # [win]
+    # no compile tests here, as used compiler might be not upward-compatible
+    # needs to be fixed
+    - {{ compiler('c') }}    # [not osx]
+    - {{ compiler('cxx') }}  # [not osx]
+  source_files:
+    - testsuite/libffi.bhaible
+    - testsuite
+
+about:
+  home: https://sourceware.org/libffi/
+  license: MIT
+  license_file: LICENSE
+  license_family: MIT
+  summary: A Portable Foreign Function Interface Library
+  description: |
+    The libffi library provides a portable, high level programming interface
+    to various calling conventions. This allows a programmer to call any
+    function specified by a call interface description at run-time.
+  doc_url: https://sourceware.org/libffi/
+  dev_url: https://github.com/libffi/libffi
+
+extra:
+  recipe-maintainers:
+    - stefan-balke
+    - scopatz
+    - isuruf

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/run_test.bat

@@ -0,0 +1,9 @@
+if not exist %LIBRARY_PREFIX%/bin/ffi-7.dll exit /b 1
+if not exist %LIBRARY_PREFIX%/lib/libffi.lib exit /b 1
+if not exist %LIBRARY_PREFIX%/lib/ffi.lib exit /b 1
+if not exist %LIBRARY_PREFIX%/lib/pkgconfig/libffi.pc exit /b 1
+if not exist %LIBRARY_PREFIX%/include/ffi.h exit /b 1
+if not exist %LIBRARY_PREFIX%/include/ffitarget.h exit /b 1
+echo "platform name"
+echo %SUBDIR%
+if %SUBDIR%==win-64 (llvm-nm %LIBRARY_PREFIX%/lib/libffi.lib | grep "__imp_ffi_type_void" ) else (llvm-nm %LIBRARY_PREFIX%/lib/libffi.lib | grep "__imp__ffi_type_void")

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/run_test.sh

@@ -0,0 +1,14 @@
+set -ex
+test -e $PREFIX/lib/libffi${SHLIB_EXT}
+test -e $PREFIX/lib/libffi.a
+test -e $PREFIX/lib/pkgconfig/libffi.pc
+test -e $PREFIX/include/ffi.h
+test -e $PREFIX/include/ffitarget.h
+cd $PWD/testsuite/libffi.bhaible
+echo "Triggering libffi tests"
+if [[ $(uname) == Darwin ]]; then
+  echo "ignore compile test due possible incompatiblity ..."
+else
+  make prefix=$PREFIX CC=$CC
+fi
+echo "completed triggering the tests"

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/recipe/win_cmake.patch

@@ -0,0 +1,706 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+new file mode 100644
+index 0000000..26cc2fd
+--- /dev/null
++++ b/CMakeLists.txt
+@@ -0,0 +1,61 @@
++cmake_minimum_required(VERSION 2.8.8)
++project(libffi C)
++
++set(SOURCES_LIST
++    src/closures.c
++    src/java_raw_api
++    src/prep_cif.c
++    src/raw_api.c
++    src/tramp.c
++    src/types.c)
++
++if(CMAKE_BUILD_TYPE MATCHES DEBUG)
++    list(APPEND SOURCES_LIST src/debug.c)
++    add_definitions(-DFFI_DEBUG)
++endif()
++
++include(configure_platform.cmake)
++include(configure_options.cmake)
++
++file(COPY ${FFI_CONFIG_FILE} DESTINATION ${CMAKE_BINARY_DIR})
++file(COPY src/${TARGETDIR}/ffitarget.h DESTINATION ${CMAKE_BINARY_DIR}/include)
++
++include_directories(${CMAKE_BINARY_DIR}/include)
++include_directories(${CMAKE_BINARY_DIR})
++include_directories(include)
++
++add_definitions(-DFFI_BUILDING)
++
++add_library(objlib OBJECT ${SOURCES_LIST})
++set_property(TARGET objlib PROPERTY POSITION_INDEPENDENT_CODE 1)
++
++add_library(ffi_static STATIC $<TARGET_OBJECTS:objlib>)
++
++if(MSVC)
++    add_definitions(-DFFI_BUILDING_DLL)
++    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
++elseif(CMAKE_SYSTEM_NAME MATCHES Darwin)
++    set(CMAKE_MACOSX_RPATH 1)
++endif()
++add_library(ffi_shared SHARED $<TARGET_OBJECTS:objlib> ${OBJECTS_LIST})
++
++set_target_properties(ffi_static PROPERTIES OUTPUT_NAME ffi)
++set_target_properties(ffi_shared PROPERTIES OUTPUT_NAME ffi)
++
++install(TARGETS ffi_static ffi_shared
++    EXPORT ${PROJECT_NAME}Targets
++    RUNTIME DESTINATION bin
++    ARCHIVE DESTINATION lib
++    LIBRARY DESTINATION lib)
++
++install(EXPORT ${PROJECT_NAME}Targets
++    DESTINATION share/${PROJECT_NAME})
++
++install(FILES
++    ${CMAKE_BINARY_DIR}/include/ffi.h
++    ${CMAKE_BINARY_DIR}/include/ffitarget.h
++    DESTINATION include)
++
++install(FILES
++    ${CMAKE_LIBRARY_DIR}/pkgconfig/libffi.pc
++    DESTINATION lib/pkgconfig)
+diff --git a/configure_options.cmake b/configure_options.cmake
+new file mode 100644
+index 0000000..849231c
+--- /dev/null
++++ b/configure_options.cmake
+@@ -0,0 +1,341 @@
++include(CheckCSourceCompiles)
++include(CheckCSourceRuns)
++include(CheckFunctionExists)
++include(CheckIncludeFile)
++include(CheckIncludeFiles)
++include(CheckSymbolExists)
++include(CheckTypeSize)
++
++# options in AC counterpart can be overriden from command-line
++# e.g.:  cmake .. -DFFI_MMAP_EXEC_EMUTRAMP_PAX=1 -DVERSION=X.Y
++if(NOT DEFINED VERSION)
++    set(VERSION 3.x-dev)
++endif()
++set(PACKAGE libffi)
++set(PACKAGE_BUGREPORT http://github.com/libffi/libffi/issues)
++set(PACKAGE_NAME ${PACKAGE})
++set(PACKAGE_STRING "${PACKAGE} ${VERSION}")
++set(PACKAGE_TARNAME ${PACKAGE})
++set(PACKAGE_URL http://github.com/libffi/libffi)
++set(PACKAGE_VERSION ${VERSION})
++set(TARGET ${TARGET_PLATFORM})
++set(LT_OBJDIR .libs/)
++set(prefix ../..)
++set(exec_prefix \${prefix})
++set(libdir \${exec_prefix}/lib)
++set(toolexeclibdir \${exec_prefix}/lib)
++set(includedir \${prefix}/include)
++
++check_type_size (size_t SIZEOF_SIZE_T)
++
++if(SIZEOF_SIZE_T STREQUAL "")
++    set(size_t "unsinged int")
++endif()
++
++if(MSVC)
++    get_filename_component(COMPILER_DIR "${CMAKE_C_COMPILER}" DIRECTORY)
++else()
++    enable_language(ASM)
++endif()
++
++set(FFI_EXEC_TRAMPOLINE_TABLE 0)
++if(TARGET_PLATFORM STREQUAL X86_WIN64)
++    if(MSVC)
++        list(APPEND WIN_ASSEMBLY_LIST src/x86/win64_intel.S)
++        enable_language(ASM_MASM)
++    else()
++        list(APPEND SOURCES_LIST src/x86/win64.S)
++    endif()
++    list(APPEND SOURCES_LIST src/x86/ffiw64.c)
++
++    set(TARGETDIR x86)
++elseif(TARGET_PLATFORM STREQUAL X86_64)
++    list(APPEND SOURCES_LIST
++        src/x86/ffi64.c
++        src/x86/unix64.S)
++
++    if(SIZEOF_SIZE_T EQUAL 4 AND TARGET_PLATFORM MATCHES X86.*)
++        set(CMAKE_REQUIRED_FLAGS "-Werror")
++
++        check_c_source_compiles(
++            "
++            int main(void)
++            {
++                return __x86_64__;
++            }
++            "
++            TARGET_X32)
++
++        set(CMAKE_REQUIRED_FLAGS)
++    endif()
++
++    if(NOT TARGET_X32)
++        list(APPEND SOURCES_LIST
++             src/x86/ffiw64.c
++             src/x86/win64.S)
++    endif()
++
++    set(TARGETDIR x86)
++elseif(TARGET_PLATFORM MATCHES X86.*)
++    if(MSVC)
++        list(APPEND WIN_ASSEMBLY_LIST src/x86/sysv_intel.S)
++        enable_language(ASM_MASM)
++    else()
++        list(APPEND SOURCES_LIST src/x86/sysv.S)
++    endif()
++
++    list(APPEND SOURCES_LIST src/x86/ffi.c)
++    set(TARGETDIR x86)
++elseif(TARGET_PLATFORM MATCHES ARM_WIN64|AARCH64)
++    if(TARGET_PLATFORM STREQUAL ARM_WIN64)
++        set(CMAKE_ASM_MASM_COMPILER ${COMPILER_DIR}/armasm64.exe)
++        set(CMAKE_ASM_COMPILER ${CMAKE_ASM_MASM_COMPILER})
++        list(APPEND WIN_ASSEMBLY_LIST src/aarch64/win64_armasm.S)
++        file(COPY src/aarch64/ffitarget.h DESTINATION ${CMAKE_BINARY_DIR}/include)
++        enable_language(ASM)
++    else()
++        list(APPEND SOURCES_LIST src/aarch64/sysv.S)
++    endif()
++
++    list(APPEND SOURCES_LIST src/aarch64/ffi.c)
++    set(TARGETDIR aarch64)
++elseif(TARGET_PLATFORM MATCHES ARM.*)
++    if(MSVC)
++        set(CMAKE_ASM_MASM_COMPILER ${COMPILER_DIR}/armasm.exe)
++        set(CMAKE_ASM_COMPILER ${CMAKE_ASM_MASM_COMPILER})
++        list(APPEND WIN_ASSEMBLY_LIST src/arm/sysv_msvc_arm32.S)
++        file(COPY src/arm/ffitarget.h DESTINATION ${CMAKE_BINARY_DIR}/include)
++        enable_language(ASM)
++    else()
++        list(APPEND SOURCES_LIST src/arm/sysv.S)
++    endif()
++
++    list(APPEND SOURCES_LIST src/arm/ffi.c)
++    set(TARGETDIR arm)
++endif()
++
++if(CMAKE_SYSTEM_NAME STREQUAL Darwin AND TARGET_PLATFORM STREQUAL AARCH64)
++    set(FFI_EXEC_TRAMPOLINE_TABLE 1)
++elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin OR TARGET_PLATFORM MATCHES .*FREEBSD.*)
++    set(FFI_MMAP_EXEC_WRIT 1)
++endif()
++
++check_type_size (double SIZEOF_DOUBLE)
++check_type_size ("long double" SIZEOF_LONG_DOUBLE)
++
++if(SIZEOF_LONG_DOUBLE STREQUAL "")
++    set(HAVE_LONG_DOUBLE 0)
++
++    if(DEFINED HAVE_LONG_DOUBLE_VARIANT)
++        set(HAVE_LONG_DOUBLE 1)
++    elseif(NOT SIZEOF_DOUBLE EQUAL SIZEOF_LONG_DOUBLE)
++        set(HAVE_LONG_DOUBLE 1)
++    endif()
++else()
++    set(HAVE_LONG_DOUBLE 1)
++endif()
++
++check_function_exists(alloca  C_ALLOCA)
++check_function_exists (mmap HAVE_MMAP)
++
++check_symbol_exists (MAP_ANON sys/mman.h HAVE_MMAP_ANON)
++
++check_c_source_runs(
++    "
++    #include <stdlib.h>
++    #include <sys/types.h>
++    #include <sys/mman.h>
++    #include <fcntl.h>
++
++    int main(void) {
++        int devzero = open(\"/dev/zero\", O_RDWR);
++        return devzero == -1 || mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, devzero, 0) == (void *)-1 ? 1 : 0;
++    }" HAVE_MMAP_DEV_ZERO)
++
++check_include_file(alloca.h HAVE_ALLOCA_H)
++
++check_c_source_compiles(
++    "
++    #include <alloca.h>
++    int main()
++    {
++        char* x = alloca(1024);
++        return 0;
++    }
++    "
++    HAVE_ALLOCA)
++
++check_include_file(dlfcn.h HAVE_DLFCN_H)
++check_include_file(inttypes.h HAVE_INTTYPES_H)
++check_include_file(memory.h HAVE_MEMORY_H)
++check_include_file(stdint.h HAVE_STDINT_H)
++check_include_file(stdlib.h HAVE_STDLIB_H)
++check_include_file(strings.h HAVE_STRINGS_H)
++check_include_file(string.h HAVE_STRING_H)
++check_include_file(sys/mman.h HAVE_SYS_MMAN_H)
++check_include_file(sys/stat.h HAVE_SYS_STAT_H)
++check_include_file(sys/types.h HAVE_SYS_TYPES_H)
++check_include_file(unistd.h HAVE_UNISTD_H)
++check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
++
++check_symbol_exists(memcpy string.h HAVE_MEMCPY)
++set(CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE")
++check_symbol_exists(mkostemp stdlib.h HAVE_MKOSTEMP)
++set(CMAKE_REQUIRED_DEFINITIONS)
++
++if (NOT MSVC)
++    find_program(OBJDUMP objdump)
++    find_program(NM NAMES nm llvm-nm)
++
++    if(OBJDUMP)
++        set(DUMPTOOL_CMD "objdump -t -h") # on macOS -t -h can't be combined
++        set(EH_FRAME_GREP_EXPR "grep -A1 -n eh_frame | grep -q READONLY")
++    elseif(NM)
++        set(DUMPTOOL_CMD "nm -a")
++        set(EH_FRAME_GREP_EXPR "grep -q ' r \.eh_frame'")
++    endif()
++
++    execute_process(
++        COMMAND
++            sh -c "echo 'extern void foo (void); void bar (void) { foo (); foo (); }' | ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -xc -c -fpic -fexceptions -o conftest.o - 2>&1;
++                   ${DUMPTOOL_CMD} conftest.o 2>&1 | ${EH_FRAME_GREP_EXPR}"
++        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++        OUTPUT_VARIABLE IGNORE
++        ERROR_VARIABLE IGNORE
++        RESULT_VARIABLE HAVE_RO_EH_FRAME_EXITCODE)
++
++    file(REMOVE ${CMAKE_BINARY_DIR}/conftest.*)
++
++    if(HAVE_RO_EH_FRAME_EXITCODE EQUAL "0")
++        set(HAVE_RO_EH_FRAME 1)
++        set(EH_FRAME_FLAGS "a")
++        message(STATUS "Checking if .eh_frame section is read-only - yes")
++    else()
++        set(EH_FRAME_FLAGS "aw")
++        message(STATUS "Checking if .eh_frame section is read-only - no")
++    endif()
++
++    execute_process(
++        COMMAND sh -c "echo '.text; foo: nop; .data; .long foo-.; .text' | ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -xassembler -c -o conftest.o - 2>&1"
++        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++        OUTPUT_VARIABLE IGNORE
++        ERROR_VARIABLE IGNORE
++        RESULT_VARIABLE HAVE_AS_X86_PCREL_EXITCODE)
++
++    file(REMOVE ${CMAKE_BINARY_DIR}/conftest.*)
++
++    if(HAVE_AS_X86_PCREL_EXITCODE EQUAL "0")
++        set(HAVE_AS_X86_PCREL 1)
++        message(STATUS "Checking HAVE_AS_X86_PCREL - yes")
++    else()
++        message(STATUS "Checking HAVE_AS_X86_PCREL - no")
++    endif()
++
++    execute_process(
++        COMMAND
++            sh -c "echo '.text;.globl foo;foo:;jmp bar;.section .eh_frame,\"a\",@unwind;bar:' | ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -xassembler -Wa,--fatal-warnings -c -o conftest.o - 2>&1 &&
++                   echo 'extern void foo();int main(){foo();}' | ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} conftest.o -xc - 2>&1"
++        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++        OUTPUT_VARIABLE IGNORE
++        ERROR_VARIABLE IGNORE
++        RESULT_VARIABLE HAVE_AS_X86_64_UNWIND_SECTION_TYPE_EXITCODE)
++
++    file(REMOVE ${CMAKE_BINARY_DIR}/conftest.*)
++
++    if(HAVE_AS_X86_64_UNWIND_SECTION_TYPE_EXITCODE EQUAL "0")
++        set(HAVE_AS_X86_64_UNWIND_SECTION_TYPE 1)
++        message(STATUS "Checking HAVE_AS_X86_64_UNWIND_SECTION_TYPE - yes")
++    else()
++        message(STATUS "Checking HAVE_AS_X86_64_UNWIND_SECTION_TYPE - no")
++    endif()
++
++    execute_process(
++        COMMAND sh -c "echo 'int __attribute__ ((visibility (\"hidden\"))) foo(void){return 1;}' | ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -xc -Werror -S -o- - 2>&1 |
++                       grep -q '\\.hidden.*foo'"
++        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++        OUTPUT_VARIABLE IGNORE
++        ERROR_VARIABLE IGNORE
++        RESULT_VARIABLE HAVE_HIDDEN_VISIBILITY_ATTRIBUTE_EXITCODE)
++
++    if(HAVE_HIDDEN_VISIBILITY_ATTRIBUTE_EXITCODE EQUAL "0")
++        set(HAVE_HIDDEN_VISIBILITY_ATTRIBUTE 1)
++        message(STATUS "Checking HAVE_HIDDEN_VISIBILITY_ATTRIBUTE - yes")
++    else()
++        message(STATUS "Checking HAVE_HIDDEN_VISIBILITY_ATTRIBUTE - no")
++    endif()
++endif()
++
++file(WRITE ${CMAKE_BINARY_DIR}/conftest.c "void nm_test_func(){} int main(){nm_test_func();return 0;}")
++
++if(MSVC)
++    execute_process(
++        COMMAND "${CMAKE_C_COMPILER}" ${CMAKE_C_FLAGS} /c conftest.c
++        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++        OUTPUT_VARIABLE IGNORE
++        ERROR_VARIABLE IGNORE
++        RESULT_VARIABLE SYMBOL_UNDERSCORE_EXITCODE)
++
++    if(SYMBOL_UNDERSCORE_EXITCODE EQUAL "0")
++        execute_process(
++            COMMAND "${COMPILER_DIR}/dumpbin.exe" /ALL /RAWDATA:NONE conftest.obj | findstr _nm_test_func > NUL
++            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++            OUTPUT_VARIABLE IGNORE
++            ERROR_VARIABLE IGNORE
++            RESULT_VARIABLE SYMBOL_UNDERSCORE_EXITCODE)
++    endif()
++elseif()
++    execute_process(
++        COMMAND sh -c "${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -xc -c -o conftest.o conftest.c 2>&1;
++                       ${DUMPTOOL_CMD} conftest.o 2>&1 | grep -q _nm_test_func"
++        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
++        OUTPUT_VARIABLE IGNORE
++        ERROR_VARIABLE IGNORE
++        RESULT_VARIABLE SYMBOL_UNDERSCORE_EXITCODE)
++endif()
++
++file(REMOVE ${CMAKE_BINARY_DIR}/conftest.*)
++
++if(SYMBOL_UNDERSCORE_EXITCODE EQUAL "0")
++    set(SYMBOL_UNDERSCORE 1)
++    message(STATUS "Checking if symbols are underscored - yes")
++else()
++    message(STATUS "Checking if symbols are underscored - no")
++endif()
++
++check_c_source_compiles(
++    "
++    asm (\".cfi_sections\\\\n\\\\t.cfi_startproc\\\\n\\\\t.cfi_endproc\");
++    int main(void)
++    {
++        return 0;
++    }
++    "
++    HAVE_AS_CFI_PSEUDO_OP)
++
++configure_file(include/ffi.h.in ${CMAKE_BINARY_DIR}/include/ffi.h)
++configure_file(include/fficonfig.h.in ${CMAKE_BINARY_DIR}/include/fficonfig.h)
++configure_file(libffi.pc.in ${CMAKE_LIBRARY_DIR}/pkgconfig/libffi.pc)
++
++foreach(ASM_PATH IN LISTS WIN_ASSEMBLY_LIST)
++    get_filename_component(ASM_FILENAME "${ASM_PATH}" NAME_WE)
++    get_filename_component(ASM_DIRNAME "${ASM_PATH}" DIRECTORY)
++
++    add_custom_command(
++        COMMAND "${CMAKE_C_COMPILER}" /nologo /P /EP /I. /I"${CMAKE_CURRENT_SOURCE_DIR}/${ASM_DIRNAME}" /Fi"${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm" /Iinclude
++                /I"${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/${ASM_PATH}"
++        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${ASM_PATH}
++        OUTPUT ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm
++        COMMENT "Preprocessing ${CMAKE_CURRENT_SOURCE_DIR}/${ASM_PATH}. Outputting to ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm")
++
++    set_source_files_properties("${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm" PROPERTIES GENERATED TRUE)
++
++    add_custom_command(
++        COMMAND "${CMAKE_ASM_MASM_COMPILER}" /Fo "${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj" "${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm"
++        DEPENDS ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm
++        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj
++        COMMENT "Assembling ${CMAKE_BINARY_DIR}/${ASM_FILENAME}.asm")
++
++    set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj PROPERTIES EXTERNAL_OBJECT TRUE)
++
++    list(APPEND OBJECTS_LIST ${CMAKE_CURRENT_BINARY_DIR}/${ASM_FILENAME}.obj)
++endforeach()
+diff --git a/configure_platform.cmake b/configure_platform.cmake
+new file mode 100644
+index 0000000..bc57a65
+--- /dev/null
++++ b/configure_platform.cmake
+@@ -0,0 +1,43 @@
++if("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "")
++    set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR})
++else()
++    set(HOST_ARCH ${CMAKE_C_COMPILER_ARCHITECTURE_ID})
++endif()
++
++if("${TARGET_PLATFORM}" STREQUAL "")
++    if(HOST_ARCH MATCHES x64|x86_64|AMD64|amd64)
++        if(CMAKE_SYSTEM_NAME STREQUAL Windows)
++            set(TARGET_PLATFORM X86_WIN64)
++        else()
++            set(TARGET_PLATFORM X86_64)
++        endif()
++    elseif(HOST_ARCH MATCHES i.*86.*|X86|x86)
++        if(MSVC)
++            set(TARGET_PLATFORM X86_WIN32)
++        else()
++            set(TARGET_PLATFORM X86)
++        endif()
++
++        if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
++            set(TARGET_PLATFORM X86_DARWIN)
++        elseif(CMAKE_SYSTEM_NAME MATCHES FreeBSD|OpenBSD)
++            set(TARGET_PLATFORM X86_FREEBSD)
++        endif()
++    elseif(HOST_ARCH MATCHES aarch64|ARM64|arm64)
++        if(MSVC)
++            set(TARGET_PLATFORM ARM_WIN64)
++        else()
++            set(TARGET_PLATFORM AARCH64)
++        endif()
++    elseif(HOST_ARCH MATCHES arm.*|ARM.*)
++        if(MSVC)
++            set(TARGET_PLATFORM ARM_WIN32)
++        else()
++            set(TARGET_PLATFORM ARM)
++        endif()
++    else()
++        message(FATAL_ERROR "Unknown host.")
++    endif()
++endif()
++
++message(STATUS "Building for TARGET_PLATFORM: ${TARGET_PLATFORM}")
+diff --git a/include/fficonfig.h.in b/include/fficonfig.h.in
+new file mode 100644
+index 0000000..1b36207
+--- /dev/null
++++ b/include/fficonfig.h.in
+@@ -0,0 +1,210 @@
++/* fficonfig.h.in.  Generated from configure.ac by autoheader.  */
++
++/* Define if building universal (internal helper macro) */
++#cmakedefine AC_APPLE_UNIVERSAL_BUILD
++
++/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
++   systems. This function is required for `alloca.c' support on those systems.
++   */
++#cmakedefine CRAY_STACKSEG_END "@CRAY_STACKSEG_END@"
++
++/* Define if using `alloca.c'. */
++#cmakedefine C_ALLOCA
++
++/* Define to the flags needed for the .section .eh_frame directive. */
++#cmakedefine EH_FRAME_FLAGS "@EH_FRAME_FLAGS@"
++
++/* Define this if you want extra debugging. */
++#cmakedefine FFI_DEBUG
++
++/* Cannot use PROT_EXEC on this target, so, we revert to alternative means */
++#cmakedefine FFI_EXEC_TRAMPOLINE_TABLE
++
++/* Define this if you want to enable pax emulated trampolines */
++#cmakedefine FFI_MMAP_EXEC_EMUTRAMP_PAX
++
++/* Cannot use malloc on this target, so, we revert to alternative means */
++#cmakedefine01 FFI_MMAP_EXEC_WRIT
++
++/* Define this if you do not want support for the raw API. */
++#cmakedefine01 FFI_NO_RAW_API
++
++/* Define this if you do not want support for aggregate types. */
++#cmakedefine01 FFI_NO_STRUCTS
++
++/* Define to 1 if you have `alloca', as a function or macro. */
++#cmakedefine01 HAVE_ALLOCA
++
++/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
++   */
++#cmakedefine01 HAVE_ALLOCA_H
++
++/* Define if your assembler supports .cfi_* directives. */
++#cmakedefine HAVE_AS_CFI_PSEUDO_OP
++
++/* Define if your assembler supports .register. */
++#cmakedefine HAVE_AS_REGISTER_PSEUDO_OP
++
++/* Define if the compiler uses zarch features. */
++#cmakedefine HAVE_AS_S390_ZARCH
++
++/* Define if your assembler and linker support unaligned PC relative relocs.
++   */
++#cmakedefine HAVE_AS_SPARC_UA_PCREL
++
++/* Define if your assembler supports unwind section type. */
++#cmakedefine HAVE_AS_X86_64_UNWIND_SECTION_TYPE
++
++/* Define if your assembler supports PC relative relocs. */
++#cmakedefine HAVE_AS_X86_PCREL
++
++/* Define to 1 if you have the <dlfcn.h> header file. */
++#cmakedefine01 HAVE_DLFCN_H
++
++/* Define if __attribute__((visibility("hidden"))) is supported. */
++#cmakedefine HAVE_HIDDEN_VISIBILITY_ATTRIBUTE
++
++/* Define to 1 if you have the <inttypes.h> header file. */
++#cmakedefine01 HAVE_INTTYPES_H
++
++/* Define if you have the long double type and it is bigger than a double */
++#cmakedefine01 HAVE_LONG_DOUBLE
++
++/* Define if you support more than one size of the long double type */
++#cmakedefine HAVE_LONG_DOUBLE_VARIANT
++
++/* Define to 1 if you have the `memcpy' function. */
++#cmakedefine01 HAVE_MEMCPY
++
++/* Define to 1 if you have the <memory.h> header file. */
++#cmakedefine01 HAVE_MEMORY_H
++
++/* Define to 1 if you have the `mkostemp' function. */
++#cmakedefine01 HAVE_MKOSTEMP
++
++/* Define to 1 if you have the `mmap' function. */
++#cmakedefine01 HAVE_MMAP
++
++/* Define if mmap with MAP_ANON(YMOUS) works. */
++#cmakedefine HAVE_MMAP_ANON
++
++/* Define if mmap of /dev/zero works. */
++#cmakedefine HAVE_MMAP_DEV_ZERO
++
++/* Define if read-only mmap of a plain file works. */
++#cmakedefine HAVE_MMAP_FILE
++
++/* Define if .eh_frame sections should be read-only. */
++#cmakedefine HAVE_RO_EH_FRAME
++
++/* Define to 1 if you have the <stdint.h> header file. */
++#cmakedefine01 HAVE_STDINT_H
++
++/* Define to 1 if you have the <stdlib.h> header file. */
++#cmakedefine01 HAVE_STDLIB_H
++
++/* Define to 1 if you have the <strings.h> header file. */
++#cmakedefine01 HAVE_STRINGS_H
++
++/* Define to 1 if you have the <string.h> header file. */
++#cmakedefine01 HAVE_STRING_H
++
++/* Define to 1 if you have the <sys/mman.h> header file. */
++#cmakedefine01 HAVE_SYS_MMAN_H
++
++/* Define to 1 if you have the <sys/stat.h> header file. */
++#cmakedefine01 HAVE_SYS_STAT_H
++
++/* Define to 1 if you have the <sys/types.h> header file. */
++#cmakedefine01 HAVE_SYS_TYPES_H
++
++/* Define to 1 if you have the <unistd.h> header file. */
++#cmakedefine01 HAVE_UNISTD_H
++
++/* Define to the sub-directory where libtool stores uninstalled libraries. */
++#cmakedefine LT_OBJDIR "@LT_OBJDIR@"
++
++/* Name of package */
++#cmakedefine PACKAGE "@PACKAGE@"
++
++/* Define to the address where bug reports for this package should be sent. */
++#cmakedefine PACKAGE_BUGREPORT "@PACKAGE_BUGREPORT@"
++
++/* Define to the full name of this package. */
++#cmakedefine PACKAGE_NAME "@PACKAGE_NAME@"
++
++/* Define to the full name and version of this package. */
++#cmakedefine PACKAGE_STRING "@PACKAGE_STRING@"
++
++/* Define to the one symbol short name of this package. */
++#cmakedefine PACKAGE_TARNAME "@PACKAGE_TARNAME@"
++
++/* Define to the home page for this package. */
++#cmakedefine PACKAGE_URL "@PACKAGE_URL@"
++
++/* Define to the version of this package. */
++#cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@"
++
++/* The size of `double', as computed by sizeof. */
++#cmakedefine SIZEOF_DOUBLE @SIZEOF_DOUBLE@
++
++/* The size of `long double', as computed by sizeof. */
++#cmakedefine SIZEOF_LONG_DOUBLE @SIZEOF_LONG_DOUBLE@
++
++/* The size of `size_t', as computed by sizeof. */
++#cmakedefine SIZEOF_SIZE_T @SIZEOF_SIZE_T@
++
++/* If using the C implementation of alloca, define if you know the
++   direction of stack growth for your system; otherwise it will be
++   automatically deduced at runtime.
++	STACK_DIRECTION > 0 => grows toward higher addresses
++	STACK_DIRECTION < 0 => grows toward lower addresses
++	STACK_DIRECTION = 0 => direction of growth unknown */
++#cmakedefine STACK_DIRECTION @STACK_DIRECTION@
++
++/* Define to 1 if you have the ANSI C header files. */
++#cmakedefine01 STDC_HEADERS
++
++/* Define if symbols are underscored. */
++#cmakedefine SYMBOL_UNDERSCORE
++
++/* Define this if you are using Purify and want to suppress spurious messages.
++   */
++#cmakedefine USING_PURIFY
++
++/* Version number of package */
++#cmakedefine VERSION "@VERSION@"
++
++/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
++   significant byte first (like Motorola and SPARC, unlike Intel). */
++#if defined AC_APPLE_UNIVERSAL_BUILD
++# if defined __BIG_ENDIAN__
++#  define WORDS_BIGENDIAN 1
++# endif
++#else
++# ifndef WORDS_BIGENDIAN
++#  undef WORDS_BIGENDIAN
++# endif
++#endif
++
++/* Define to `unsigned int' if <sys/types.h> does not define. */
++#cmakedefine size_t @size_t@
++
++
++#ifdef HAVE_HIDDEN_VISIBILITY_ATTRIBUTE
++#ifdef LIBFFI_ASM
++#ifdef __APPLE__
++#define FFI_HIDDEN(name) .private_extern name
++#else
++#define FFI_HIDDEN(name) .hidden name
++#endif
++#else
++#define FFI_HIDDEN __attribute__ ((visibility ("hidden")))
++#endif
++#else
++#ifdef LIBFFI_ASM
++#define FFI_HIDDEN(name)
++#else
++#define FFI_HIDDEN
++#endif
++#endif
+diff --git a/src/closures.c b/src/closures.c
+index 5120021..c329077 100644
+--- a/src/closures.c
++++ b/src/closures.c
+@@ -137,6 +137,7 @@ ffi_closure_free (void *ptr)
+ /* Windows systems may have Data Execution Protection (DEP) enabled,
+    which requires the use of VirtualMalloc/VirtualFree to alloc/free
+    executable memory. */
++#  undef FFI_MMAP_EXEC_WRIT
+ #  define FFI_MMAP_EXEC_WRIT 1
+ # endif
+ #endif
+diff --git a/src/dlmalloc.c b/src/dlmalloc.c
+index d63dd36..950e977 100644
+--- a/src/dlmalloc.c
++++ b/src/dlmalloc.c
+@@ -451,6 +451,7 @@ DEFAULT_MMAP_THRESHOLD       default: 256K
+ #ifdef WIN32
+ #define WIN32_LEAN_AND_MEAN
+ #include <windows.h>
++#undef HAVE_MMAP
+ #define HAVE_MMAP 1
+ #define HAVE_MORECORE 0
+ #define LACKS_UNISTD_H
+-- 
+2.23.0
+

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/repodata_record.json

@@ -0,0 +1,23 @@
+{
+  "arch": "x86_64",
+  "build": "h6a678d5_1",
+  "build_number": 1,
+  "channel": "https://repo.anaconda.com/pkgs/main/linux-64/",
+  "constrains": [],
+  "depends": [
+    "libgcc-ng >=11.2.0",
+    "libstdcxx-ng >=11.2.0"
+  ],
+  "fn": "libffi-3.4.4-h6a678d5_1.conda",
+  "license": "MIT",
+  "license_family": "MIT",
+  "md5": "70646cc713f0c43926cfdcfe9b695fe0",
+  "name": "libffi",
+  "platform": "linux",
+  "sha256": "b0e7fe2e5d498bc5a2c57cf942701bba8f22ec55de55e092ffbffc40b816df88",
+  "size": 144691,
+  "subdir": "linux-64",
+  "timestamp": 1714483282000,
+  "url": "https://repo.anaconda.com/pkgs/main/linux-64/libffi-3.4.4-h6a678d5_1.conda",
+  "version": "3.4.4"
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/run_exports.json

@@ -0,0 +1 @@
+{"weak": ["libffi >=3.4,<4.0a0"]}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/run_test.sh

@@ -0,0 +1,14 @@
+set -ex
+test -e $PREFIX/lib/libffi${SHLIB_EXT}
+test -e $PREFIX/lib/libffi.a
+test -e $PREFIX/lib/pkgconfig/libffi.pc
+test -e $PREFIX/include/ffi.h
+test -e $PREFIX/include/ffitarget.h
+cd $PWD/testsuite/libffi.bhaible
+echo "Triggering libffi tests"
+if [[ $(uname) == Darwin ]]; then
+  echo "ignore compile test due possible incompatiblity ..."
+else
+  make prefix=$PREFIX CC=$CC
+fi
+echo "completed triggering the tests"

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/test_time_dependencies.json

@@ -0,0 +1 @@
+["make", "gxx_linux-64 11.2.0.*", "gcc_linux-64 11.2.0.*"]

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/Makefile.am

@@ -0,0 +1,133 @@
+## Process this file with automake to produce Makefile.in.
+
+AUTOMAKE_OPTIONS = foreign dejagnu
+
+EXTRA_DEJAGNU_SITE_CONFIG=../local.exp
+
+CLEANFILES = *.exe core* *.log *.sum
+
+EXTRA_DIST = config/default.exp lib/libffi.exp lib/target-libpath.exp	\
+lib/wrapper.exp libffi.bhaible/Makefile libffi.bhaible/README		\
+libffi.bhaible/alignof.h libffi.bhaible/bhaible.exp			\
+libffi.bhaible/test-call.c libffi.bhaible/test-callback.c		\
+libffi.bhaible/testcases.c libffi.call/align_mixed.c			\
+libffi.call/align_stdcall.c libffi.call/call.exp			\
+libffi.call/err_bad_typedef.c libffi.call/ffitest.h			\
+libffi.call/float.c libffi.call/float1.c libffi.call/float2.c		\
+libffi.call/float3.c libffi.call/float4.c libffi.call/float_va.c	\
+libffi.call/many.c libffi.call/many2.c libffi.call/many_double.c	\
+libffi.call/many_mixed.c libffi.call/negint.c libffi.call/offsets.c	\
+libffi.call/pr1172638.c libffi.call/promotion.c				\
+libffi.call/pyobjc_tc.c libffi.call/return_dbl.c			\
+libffi.call/return_dbl1.c libffi.call/return_dbl2.c			\
+libffi.call/return_fl.c libffi.call/return_fl1.c			\
+libffi.call/return_fl2.c libffi.call/return_fl3.c			\
+libffi.call/return_ldl.c libffi.call/return_ll.c			\
+libffi.call/return_ll1.c libffi.call/return_sc.c			\
+libffi.call/return_sl.c libffi.call/return_uc.c				\
+libffi.call/return_ul.c libffi.call/struct1.c libffi.call/struct10.c	\
+libffi.call/struct2.c libffi.call/struct3.c libffi.call/struct4.c	\
+libffi.call/struct5.c libffi.call/struct6.c libffi.call/struct7.c	\
+libffi.call/struct8.c libffi.call/struct9.c				\
+libffi.call/uninitialized.c libffi.call/va_1.c libffi.call/va_2.c	\
+libffi.call/va_3.c libffi.call/va_struct1.c libffi.call/va_struct2.c	\
+libffi.call/va_struct3.c libffi.call/struct_by_value_big.c		\
+libffi.call/struct_by_value_2.c libffi.call/struct_by_value_3.c		\
+libffi.call/struct_by_value_4.c libffi.call/struct_by_value_small.c	\
+libffi.call/strlen2.c libffi.call/strlen3.c libffi.call/strlen4.c	\
+libffi.call/strlen.c libffi.call/va_3.c					\
+libffi.call/struct_by_value_2.c libffi.call/struct_by_value_3.c		\
+libffi.call/struct_by_value_4.c libffi.closures/closure.exp		\
+libffi.call/s55.c libffi.call/bpo-38748.c                               \
+libffi.closures/closure_fn0.c libffi.closures/closure_fn1.c		\
+libffi.closures/closure_fn2.c libffi.closures/closure_fn3.c		\
+libffi.closures/closure_fn4.c libffi.closures/closure_fn5.c		\
+libffi.closures/closure_fn6.c libffi.closures/closure_loc_fn0.c		\
+libffi.closures/closure_simple.c libffi.closures/cls_12byte.c		\
+libffi.closures/cls_16byte.c libffi.closures/cls_18byte.c		\
+libffi.closures/cls_19byte.c libffi.closures/cls_1_1byte.c		\
+libffi.closures/cls_20byte.c libffi.closures/cls_20byte1.c		\
+libffi.closures/cls_24byte.c libffi.closures/cls_2byte.c		\
+libffi.closures/cls_3_1byte.c libffi.closures/cls_3byte1.c		\
+libffi.closures/cls_3byte2.c libffi.closures/cls_3float.c		\
+libffi.closures/cls_4_1byte.c libffi.closures/cls_4byte.c		\
+libffi.closures/cls_5_1_byte.c libffi.closures/cls_5byte.c		\
+libffi.closures/cls_64byte.c libffi.closures/cls_6_1_byte.c		\
+libffi.closures/cls_6byte.c libffi.closures/cls_7_1_byte.c		\
+libffi.closures/cls_7byte.c libffi.closures/cls_8byte.c			\
+libffi.closures/cls_9byte1.c libffi.closures/cls_9byte2.c		\
+libffi.closures/cls_align_double.c libffi.closures/cls_align_float.c	\
+libffi.closures/cls_align_longdouble.c					\
+libffi.closures/cls_align_pointer.c					\
+libffi.closures/cls_align_sint16.c libffi.closures/cls_align_sint32.c	\
+libffi.closures/cls_align_sint64.c libffi.closures/cls_align_uint16.c	\
+libffi.closures/cls_align_uint32.c libffi.closures/cls_align_uint64.c	\
+libffi.closures/cls_dbls_struct.c libffi.closures/cls_double.c		\
+libffi.closures/cls_double_va.c libffi.closures/cls_float.c		\
+libffi.closures/cls_longdouble_va.c					\
+libffi.closures/cls_many_mixed_args.c					\
+libffi.closures/cls_many_mixed_float_double.c				\
+libffi.closures/cls_multi_schar.c libffi.closures/cls_multi_sshort.c	\
+libffi.closures/cls_multi_sshortchar.c					\
+libffi.closures/cls_multi_uchar.c libffi.closures/cls_multi_ushort.c	\
+libffi.closures/cls_multi_ushortchar.c libffi.closures/cls_pointer.c	\
+libffi.closures/cls_pointer_stack.c libffi.closures/cls_schar.c		\
+libffi.closures/cls_sint.c libffi.closures/cls_sshort.c			\
+libffi.closures/cls_struct_va1.c libffi.closures/cls_uchar.c		\
+libffi.closures/cls_uint.c libffi.closures/cls_uint_va.c		\
+libffi.closures/cls_ulong_va.c libffi.closures/cls_ulonglong.c		\
+libffi.closures/cls_ushort.c libffi.closures/err_bad_abi.c		\
+libffi.closures/ffitest.h libffi.closures/nested_struct.c		\
+libffi.closures/nested_struct1.c libffi.closures/nested_struct10.c	\
+libffi.closures/nested_struct11.c libffi.closures/nested_struct12.c	\
+libffi.closures/nested_struct13.c libffi.closures/nested_struct2.c	\
+libffi.closures/nested_struct3.c libffi.closures/nested_struct4.c	\
+libffi.closures/nested_struct5.c libffi.closures/nested_struct6.c	\
+libffi.closures/nested_struct7.c libffi.closures/nested_struct8.c	\
+libffi.closures/nested_struct9.c libffi.closures/problem1.c		\
+libffi.closures/single_entry_structs1.c					\
+libffi.closures/single_entry_structs2.c					\
+libffi.closures/single_entry_structs3.c libffi.closures/stret_large.c	\
+libffi.closures/stret_large2.c libffi.closures/stret_medium.c		\
+libffi.closures/stret_medium2.c libffi.closures/testclosure.c		\
+libffi.closures/unwindtest.cc libffi.closures/unwindtest_ffi_call.cc	\
+libffi.closures/cls_align_longdouble_split.c				\
+libffi.closures/cls_align_longdouble_split2.c				\
+libffi.closures/cls_longdouble.c libffi.closures/huge_struct.c		\
+libffi.complex/cls_align_complex.inc					\
+libffi.complex/cls_align_complex_double.c				\
+libffi.complex/cls_align_complex_float.c				\
+libffi.complex/cls_align_complex_longdouble.c				\
+libffi.complex/cls_complex.inc libffi.complex/cls_complex_double.c	\
+libffi.complex/cls_complex_float.c					\
+libffi.complex/cls_complex_longdouble.c					\
+libffi.complex/cls_complex_struct.inc					\
+libffi.complex/cls_complex_struct_double.c				\
+libffi.complex/cls_complex_struct_float.c				\
+libffi.complex/cls_complex_struct_longdouble.c				\
+libffi.complex/cls_complex_va.inc					\
+libffi.complex/cls_complex_va_double.c					\
+libffi.complex/cls_complex_va_float.c					\
+libffi.complex/cls_complex_va_longdouble.c libffi.complex/complex.exp	\
+libffi.complex/complex.inc libffi.complex/complex_defs_double.inc	\
+libffi.complex/complex_defs_float.inc					\
+libffi.complex/complex_defs_longdouble.inc				\
+libffi.complex/complex_double.c libffi.complex/complex_float.c		\
+libffi.complex/complex_int.c libffi.complex/complex_longdouble.c	\
+libffi.complex/ffitest.h libffi.complex/many_complex.inc		\
+libffi.complex/many_complex_double.c					\
+libffi.complex/many_complex_float.c					\
+libffi.complex/many_complex_longdouble.c				\
+libffi.complex/return_complex.inc libffi.complex/return_complex1.inc	\
+libffi.complex/return_complex1_double.c					\
+libffi.complex/return_complex1_float.c					\
+libffi.complex/return_complex1_longdouble.c				\
+libffi.complex/return_complex2.inc					\
+libffi.complex/return_complex2_double.c					\
+libffi.complex/return_complex2_float.c					\
+libffi.complex/return_complex2_longdouble.c				\
+libffi.complex/return_complex_double.c					\
+libffi.complex/return_complex_float.c					\
+libffi.complex/return_complex_longdouble.c libffi.go/aa-direct.c	\
+libffi.go/closure1.c libffi.go/ffitest.h libffi.go/go.exp		\
+libffi.go/static-chain.h

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/Makefile.in

@@ -0,0 +1,662 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+subdir = testsuite
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/asmcfi.m4 \
+	$(top_srcdir)/m4/ax_cc_maxopt.m4 \
+	$(top_srcdir)/m4/ax_cflags_warn_all.m4 \
+	$(top_srcdir)/m4/ax_check_compile_flag.m4 \
+	$(top_srcdir)/m4/ax_compiler_vendor.m4 \
+	$(top_srcdir)/m4/ax_configure_args.m4 \
+	$(top_srcdir)/m4/ax_enable_builddir.m4 \
+	$(top_srcdir)/m4/ax_gcc_archflag.m4 \
+	$(top_srcdir)/m4/ax_gcc_x86_cpuid.m4 \
+	$(top_srcdir)/m4/ax_prepend_flag.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/fficonfig.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+DEJATOOL = $(PACKAGE)
+RUNTESTDEFAULTFLAGS = --tool $$tool --srcdir $$srcdir
+EXPECT = expect
+RUNTEST = runtest
+am__DIST_COMMON = $(srcdir)/Makefile.in
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AM_LTLDFLAGS = @AM_LTLDFLAGS@
+AM_RUNTESTFLAGS = @AM_RUNTESTFLAGS@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCAS = @CCAS@
+CCASDEPMODE = @CCASDEPMODE@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPPFLAGS = @CPPFLAGS@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FFI_EXEC_TRAMPOLINE_TABLE = @FFI_EXEC_TRAMPOLINE_TABLE@
+FGREP = @FGREP@
+GREP = @GREP@
+HAVE_LONG_DOUBLE = @HAVE_LONG_DOUBLE@
+HAVE_LONG_DOUBLE_VARIANT = @HAVE_LONG_DOUBLE_VARIANT@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPT_LDFLAGS = @OPT_LDFLAGS@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PRTDIAG = @PRTDIAG@
+RANLIB = @RANLIB@
+READELF = @READELF@
+SECTION_LDFLAGS = @SECTION_LDFLAGS@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+TARGET = @TARGET@
+TARGETDIR = @TARGETDIR@
+TARGET_OBJ = @TARGET_OBJ@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+ax_enable_builddir_sed = @ax_enable_builddir_sed@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sys_symbol_underscore = @sys_symbol_underscore@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+tmake_file = @tmake_file@
+toolexecdir = @toolexecdir@
+toolexeclibdir = $(libdir)
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AUTOMAKE_OPTIONS = foreign dejagnu
+EXTRA_DEJAGNU_SITE_CONFIG = ../local.exp
+CLEANFILES = *.exe core* *.log *.sum
+EXTRA_DIST = config/default.exp lib/libffi.exp lib/target-libpath.exp	\
+lib/wrapper.exp libffi.bhaible/Makefile libffi.bhaible/README		\
+libffi.bhaible/alignof.h libffi.bhaible/bhaible.exp			\
+libffi.bhaible/test-call.c libffi.bhaible/test-callback.c		\
+libffi.bhaible/testcases.c libffi.call/align_mixed.c			\
+libffi.call/align_stdcall.c libffi.call/call.exp			\
+libffi.call/err_bad_typedef.c libffi.call/ffitest.h			\
+libffi.call/float.c libffi.call/float1.c libffi.call/float2.c		\
+libffi.call/float3.c libffi.call/float4.c libffi.call/float_va.c	\
+libffi.call/many.c libffi.call/many2.c libffi.call/many_double.c	\
+libffi.call/many_mixed.c libffi.call/negint.c libffi.call/offsets.c	\
+libffi.call/pr1172638.c libffi.call/promotion.c				\
+libffi.call/pyobjc_tc.c libffi.call/return_dbl.c			\
+libffi.call/return_dbl1.c libffi.call/return_dbl2.c			\
+libffi.call/return_fl.c libffi.call/return_fl1.c			\
+libffi.call/return_fl2.c libffi.call/return_fl3.c			\
+libffi.call/return_ldl.c libffi.call/return_ll.c			\
+libffi.call/return_ll1.c libffi.call/return_sc.c			\
+libffi.call/return_sl.c libffi.call/return_uc.c				\
+libffi.call/return_ul.c libffi.call/struct1.c libffi.call/struct10.c	\
+libffi.call/struct2.c libffi.call/struct3.c libffi.call/struct4.c	\
+libffi.call/struct5.c libffi.call/struct6.c libffi.call/struct7.c	\
+libffi.call/struct8.c libffi.call/struct9.c				\
+libffi.call/uninitialized.c libffi.call/va_1.c libffi.call/va_2.c	\
+libffi.call/va_3.c libffi.call/va_struct1.c libffi.call/va_struct2.c	\
+libffi.call/va_struct3.c libffi.call/struct_by_value_big.c		\
+libffi.call/struct_by_value_2.c libffi.call/struct_by_value_3.c		\
+libffi.call/struct_by_value_4.c libffi.call/struct_by_value_small.c	\
+libffi.call/strlen2.c libffi.call/strlen3.c libffi.call/strlen4.c	\
+libffi.call/strlen.c libffi.call/va_3.c					\
+libffi.call/struct_by_value_2.c libffi.call/struct_by_value_3.c		\
+libffi.call/struct_by_value_4.c libffi.closures/closure.exp		\
+libffi.call/s55.c libffi.call/bpo-38748.c                               \
+libffi.closures/closure_fn0.c libffi.closures/closure_fn1.c		\
+libffi.closures/closure_fn2.c libffi.closures/closure_fn3.c		\
+libffi.closures/closure_fn4.c libffi.closures/closure_fn5.c		\
+libffi.closures/closure_fn6.c libffi.closures/closure_loc_fn0.c		\
+libffi.closures/closure_simple.c libffi.closures/cls_12byte.c		\
+libffi.closures/cls_16byte.c libffi.closures/cls_18byte.c		\
+libffi.closures/cls_19byte.c libffi.closures/cls_1_1byte.c		\
+libffi.closures/cls_20byte.c libffi.closures/cls_20byte1.c		\
+libffi.closures/cls_24byte.c libffi.closures/cls_2byte.c		\
+libffi.closures/cls_3_1byte.c libffi.closures/cls_3byte1.c		\
+libffi.closures/cls_3byte2.c libffi.closures/cls_3float.c		\
+libffi.closures/cls_4_1byte.c libffi.closures/cls_4byte.c		\
+libffi.closures/cls_5_1_byte.c libffi.closures/cls_5byte.c		\
+libffi.closures/cls_64byte.c libffi.closures/cls_6_1_byte.c		\
+libffi.closures/cls_6byte.c libffi.closures/cls_7_1_byte.c		\
+libffi.closures/cls_7byte.c libffi.closures/cls_8byte.c			\
+libffi.closures/cls_9byte1.c libffi.closures/cls_9byte2.c		\
+libffi.closures/cls_align_double.c libffi.closures/cls_align_float.c	\
+libffi.closures/cls_align_longdouble.c					\
+libffi.closures/cls_align_pointer.c					\
+libffi.closures/cls_align_sint16.c libffi.closures/cls_align_sint32.c	\
+libffi.closures/cls_align_sint64.c libffi.closures/cls_align_uint16.c	\
+libffi.closures/cls_align_uint32.c libffi.closures/cls_align_uint64.c	\
+libffi.closures/cls_dbls_struct.c libffi.closures/cls_double.c		\
+libffi.closures/cls_double_va.c libffi.closures/cls_float.c		\
+libffi.closures/cls_longdouble_va.c					\
+libffi.closures/cls_many_mixed_args.c					\
+libffi.closures/cls_many_mixed_float_double.c				\
+libffi.closures/cls_multi_schar.c libffi.closures/cls_multi_sshort.c	\
+libffi.closures/cls_multi_sshortchar.c					\
+libffi.closures/cls_multi_uchar.c libffi.closures/cls_multi_ushort.c	\
+libffi.closures/cls_multi_ushortchar.c libffi.closures/cls_pointer.c	\
+libffi.closures/cls_pointer_stack.c libffi.closures/cls_schar.c		\
+libffi.closures/cls_sint.c libffi.closures/cls_sshort.c			\
+libffi.closures/cls_struct_va1.c libffi.closures/cls_uchar.c		\
+libffi.closures/cls_uint.c libffi.closures/cls_uint_va.c		\
+libffi.closures/cls_ulong_va.c libffi.closures/cls_ulonglong.c		\
+libffi.closures/cls_ushort.c libffi.closures/err_bad_abi.c		\
+libffi.closures/ffitest.h libffi.closures/nested_struct.c		\
+libffi.closures/nested_struct1.c libffi.closures/nested_struct10.c	\
+libffi.closures/nested_struct11.c libffi.closures/nested_struct12.c	\
+libffi.closures/nested_struct13.c libffi.closures/nested_struct2.c	\
+libffi.closures/nested_struct3.c libffi.closures/nested_struct4.c	\
+libffi.closures/nested_struct5.c libffi.closures/nested_struct6.c	\
+libffi.closures/nested_struct7.c libffi.closures/nested_struct8.c	\
+libffi.closures/nested_struct9.c libffi.closures/problem1.c		\
+libffi.closures/single_entry_structs1.c					\
+libffi.closures/single_entry_structs2.c					\
+libffi.closures/single_entry_structs3.c libffi.closures/stret_large.c	\
+libffi.closures/stret_large2.c libffi.closures/stret_medium.c		\
+libffi.closures/stret_medium2.c libffi.closures/testclosure.c		\
+libffi.closures/unwindtest.cc libffi.closures/unwindtest_ffi_call.cc	\
+libffi.closures/cls_align_longdouble_split.c				\
+libffi.closures/cls_align_longdouble_split2.c				\
+libffi.closures/cls_longdouble.c libffi.closures/huge_struct.c		\
+libffi.complex/cls_align_complex.inc					\
+libffi.complex/cls_align_complex_double.c				\
+libffi.complex/cls_align_complex_float.c				\
+libffi.complex/cls_align_complex_longdouble.c				\
+libffi.complex/cls_complex.inc libffi.complex/cls_complex_double.c	\
+libffi.complex/cls_complex_float.c					\
+libffi.complex/cls_complex_longdouble.c					\
+libffi.complex/cls_complex_struct.inc					\
+libffi.complex/cls_complex_struct_double.c				\
+libffi.complex/cls_complex_struct_float.c				\
+libffi.complex/cls_complex_struct_longdouble.c				\
+libffi.complex/cls_complex_va.inc					\
+libffi.complex/cls_complex_va_double.c					\
+libffi.complex/cls_complex_va_float.c					\
+libffi.complex/cls_complex_va_longdouble.c libffi.complex/complex.exp	\
+libffi.complex/complex.inc libffi.complex/complex_defs_double.inc	\
+libffi.complex/complex_defs_float.inc					\
+libffi.complex/complex_defs_longdouble.inc				\
+libffi.complex/complex_double.c libffi.complex/complex_float.c		\
+libffi.complex/complex_int.c libffi.complex/complex_longdouble.c	\
+libffi.complex/ffitest.h libffi.complex/many_complex.inc		\
+libffi.complex/many_complex_double.c					\
+libffi.complex/many_complex_float.c					\
+libffi.complex/many_complex_longdouble.c				\
+libffi.complex/return_complex.inc libffi.complex/return_complex1.inc	\
+libffi.complex/return_complex1_double.c					\
+libffi.complex/return_complex1_float.c					\
+libffi.complex/return_complex1_longdouble.c				\
+libffi.complex/return_complex2.inc					\
+libffi.complex/return_complex2_double.c					\
+libffi.complex/return_complex2_float.c					\
+libffi.complex/return_complex2_longdouble.c				\
+libffi.complex/return_complex_double.c					\
+libffi.complex/return_complex_float.c					\
+libffi.complex/return_complex_longdouble.c libffi.go/aa-direct.c	\
+libffi.go/closure1.c libffi.go/ffitest.h libffi.go/go.exp		\
+libffi.go/static-chain.h
+
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign testsuite/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign testsuite/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+tags TAGS:
+
+ctags CTAGS:
+
+cscope cscopelist:
+
+
+check-DEJAGNU: site.exp
+	srcdir='$(srcdir)'; export srcdir; \
+	EXPECT=$(EXPECT); export EXPECT; \
+	if $(SHELL) -c "$(RUNTEST) --version" > /dev/null 2>&1; then \
+	  exit_status=0; l='$(DEJATOOL)'; for tool in $$l; do \
+	    if $(RUNTEST) $(RUNTESTDEFAULTFLAGS) $(AM_RUNTESTFLAGS) $(RUNTESTFLAGS); \
+	    then :; else exit_status=1; fi; \
+	  done; \
+	else echo "WARNING: could not find '$(RUNTEST)'" 1>&2; :;\
+	fi; \
+	exit $$exit_status
+site.exp: Makefile $(EXTRA_DEJAGNU_SITE_CONFIG)
+	@echo 'Making a new site.exp file ...'
+	@echo '## these variables are automatically generated by make ##' >site.tmp
+	@echo '# Do not edit here.  If you wish to override these values' >>site.tmp
+	@echo '# edit the last section' >>site.tmp
+	@echo 'set srcdir "$(srcdir)"' >>site.tmp
+	@echo "set objdir \"`pwd`\"" >>site.tmp
+	@echo 'set build_alias "$(build_alias)"' >>site.tmp
+	@echo 'set build_triplet $(build_triplet)' >>site.tmp
+	@echo 'set host_alias "$(host_alias)"' >>site.tmp
+	@echo 'set host_triplet $(host_triplet)' >>site.tmp
+	@echo 'set target_alias "$(target_alias)"' >>site.tmp
+	@echo 'set target_triplet $(target_triplet)' >>site.tmp
+	@list='$(EXTRA_DEJAGNU_SITE_CONFIG)'; for f in $$list; do \
+	  echo "## Begin content included from file $$f.  Do not modify. ##" \
+	   && cat `test -f "$$f" || echo '$(srcdir)/'`$$f \
+	   && echo "## End content included from file $$f. ##" \
+	   || exit 1; \
+	 done >> site.tmp
+	@echo "## End of auto-generated content; you can edit from here. ##" >> site.tmp
+	@if test -f site.exp; then \
+	   sed -e '1,/^## End of auto-generated content.*##/d' site.exp >> site.tmp; \
+	 fi
+	@-rm -f site.bak
+	@test ! -f site.exp || mv site.exp site.bak
+	@mv site.tmp site.exp
+
+distclean-DEJAGNU:
+	-rm -f site.exp site.bak
+	-l='$(DEJATOOL)'; for tool in $$l; do \
+	  rm -f $$tool.sum $$tool.log; \
+	done
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) check-DEJAGNU
+check: check-am
+all-am: Makefile
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-DEJAGNU distclean-generic
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: check-am install-am install-strip
+
+.PHONY: all all-am check check-DEJAGNU check-am clean clean-generic \
+	clean-libtool cscopelist-am ctags-am distclean \
+	distclean-DEJAGNU distclean-generic distclean-libtool distdir \
+	dvi dvi-am html html-am info info-am install install-am \
+	install-data install-data-am install-dvi install-dvi-am \
+	install-exec install-exec-am install-html install-html-am \
+	install-info install-info-am install-man install-pdf \
+	install-pdf-am install-ps install-ps-am install-strip \
+	installcheck installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \
+	uninstall-am
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/config/default.exp

@@ -0,0 +1 @@
+load_lib "standard.exp"

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/lib/libffi.exp

@@ -0,0 +1,666 @@
+#   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
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+proc load_gcc_lib { filename } {
+    global srcdir
+    load_file $srcdir/lib/$filename
+}
+
+load_lib dg.exp
+load_lib libgloss.exp
+load_gcc_lib target-libpath.exp
+load_gcc_lib wrapper.exp
+
+proc check_effective_target_gccbug { } {
+    global has_gccbug
+    return $has_gccbug
+}
+
+# Return 1 if the target matches the effective target 'arg', 0 otherwise.
+# This can be used with any check_* proc that takes no argument and
+# returns only 1 or 0.  It could be used with check_* procs that take
+# arguments with keywords that pass particular arguments.
+
+proc is-effective-target { arg } {
+    global et_index
+    set selected 0
+    if { ![info exists et_index] } {
+	# Initialize the effective target index that is used in some
+	# check_effective_target_* procs.
+	set et_index 0
+    }
+    if { [info procs check_effective_target_${arg}] != [list] } {
+	set selected [check_effective_target_${arg}]
+    } else {
+	error "unknown effective target keyword `$arg'"
+    }
+    verbose "is-effective-target: $arg $selected" 2
+    return $selected
+}
+
+proc is-effective-target-keyword { arg } {
+    if { [info procs check_effective_target_${arg}] != [list] } {
+	return 1
+    } else {
+	return 0
+    }
+}
+
+# Intercept the call to the DejaGnu version of dg-process-target to
+# support use of an effective-target keyword in place of a list of
+# target triplets to xfail or skip a test.
+#
+# The argument to dg-process-target is the keyword "target" or "xfail"
+# followed by a selector:
+#    target-triplet-1 ...
+#    effective-target-keyword
+#    selector-expression
+#
+# For a target list the result is "S" if the target is selected, "N" otherwise.
+# For an xfail list the result is "F" if the target is affected, "P" otherwise.
+
+# In contexts that allow either "target" or "xfail" the argument can be
+#    target selector1 xfail selector2
+# which returns "N" if selector1 is not selected, otherwise the result of
+# "xfail selector2".
+#
+# A selector expression appears within curly braces and uses a single logical
+# operator: !, &&, or ||.  An operand is another selector expression, an
+# effective-target keyword, or a list of target triplets within quotes or
+# curly braces.
+
+if { [info procs saved-dg-process-target] == [list] } {
+    rename dg-process-target saved-dg-process-target
+
+    # Evaluate an operand within a selector expression.
+    proc selector_opd { op } {
+	set selector "target"
+	lappend selector $op
+	set answer [ expr { [dg-process-target $selector] == "S" } ]
+	verbose "selector_opd: `$op' $answer" 2
+	return $answer
+    }
+
+    # Evaluate a target triplet list within a selector expression.
+    # Unlike other operands, this needs to be expanded from a list to
+    # the same string as "target".
+    proc selector_list { op } {
+	set selector "target [join $op]"
+	set answer [ expr { [dg-process-target $selector] == "S" } ]
+	verbose "selector_list: `$op' $answer" 2
+	return $answer
+    }
+
+    # Evaluate a selector expression.
+    proc selector_expression { exp } {
+	if { [llength $exp] == 2 } {
+	    if [string match "!" [lindex $exp 0]] {
+		set op1 [lindex $exp 1]
+		set answer [expr { ! [selector_opd $op1] }]
+	    } else {
+		# Assume it's a list of target triplets.
+		set answer [selector_list $exp]
+	    }
+	} elseif { [llength $exp] == 3 } {
+	    set op1 [lindex $exp 0]
+	    set opr [lindex $exp 1]
+	    set op2 [lindex $exp 2]
+	    if [string match "&&" $opr] {
+		set answer [expr { [selector_opd $op1] && [selector_opd $op2] }]
+	    } elseif [string match "||" $opr] {
+		set answer [expr { [selector_opd $op1] || [selector_opd $op2] }]
+	    } else {
+		# Assume it's a list of target triplets.
+		set answer [selector_list $exp]
+	    }
+	} else {
+	    # Assume it's a list of target triplets.
+	    set answer [selector_list $exp]
+	}
+
+	verbose "selector_expression: `$exp' $answer" 2
+	return $answer
+    }
+
+    # Evaluate "target selector" or "xfail selector".
+
+    proc dg-process-target-1 { args } {
+	verbose "dg-process-target-1: `$args'" 2
+
+	# Extract the 'what' keyword from the argument list.
+	set selector [string trim [lindex $args 0]]
+	if [regexp "^xfail " $selector] {
+	    set what "xfail"
+	} elseif [regexp "^target " $selector] {
+	    set what "target"
+	} else {
+	    error "syntax error in target selector \"$selector\""
+	}
+
+	# Extract the rest of the list, which might be a keyword.
+	regsub "^${what}" $selector "" rest
+	set rest [string trim $rest]
+
+	if [is-effective-target-keyword $rest] {
+	    # The selector is an effective target keyword.
+	    if [is-effective-target $rest] {
+		return [expr { $what == "xfail" ? "F" : "S" }]
+	    } else {
+		return [expr { $what == "xfail" ? "P" : "N" }]
+	    }
+	}
+
+	if [string match "{*}" $rest] {
+	    if [selector_expression [lindex $rest 0]] {
+		return [expr { $what == "xfail" ? "F" : "S" }]
+	    } else {
+		return [expr { $what == "xfail" ? "P" : "N" }]
+	    }
+	}
+
+	# The selector is not an effective-target keyword, so process
+	# the list of target triplets.
+	return [saved-dg-process-target $selector]
+    }
+
+    # Intercept calls to the DejaGnu function.  In addition to
+    # processing "target selector" or "xfail selector", handle
+    # "target selector1 xfail selector2".
+
+    proc dg-process-target { args } {
+	verbose "replacement dg-process-target: `$args'" 2
+
+	set selector [string trim [lindex $args 0]]
+
+	# If the argument list contains both 'target' and 'xfail',
+	# process 'target' and, if that succeeds, process 'xfail'.
+	if [regexp "^target .* xfail .*" $selector] {
+	    set xfail_index [string first "xfail" $selector]
+	    set xfail_selector [string range $selector $xfail_index end]
+	    set target_selector [string range $selector 0 [expr $xfail_index-1]]
+	    set target_selector [string trim $target_selector]
+	    if { [dg-process-target-1 $target_selector] == "N" } {
+		return "N"
+	    }
+	    return [dg-process-target-1 $xfail_selector]
+
+	}
+	return [dg-process-target-1 $selector]
+    }
+}
+
+# Define libffi callbacks for dg.exp.
+
+proc libffi-dg-test-1 { target_compile prog do_what extra_tool_flags } {
+
+    # To get all \n in dg-output test strings to match printf output
+    # in a system that outputs it as \015\012 (i.e. not just \012), we
+    # need to change all \n into \r?\n.  As there is no dejagnu flag
+    # or hook to do that, we simply change the text being tested.
+    # Unfortunately, we have to know that the variable is called
+    # dg-output-text and lives in the caller of libffi-dg-test, which
+    # is two calls up.  Overriding proc dg-output would be longer and
+    # would necessarily have the same assumption.
+    upvar 2 dg-output-text output_match
+
+    if { [llength $output_match] > 1 } {
+	regsub -all "\n" [lindex $output_match 1] "\r?\n" x
+	set output_match [lreplace $output_match 1 1 $x]
+    }
+
+    # Set up the compiler flags, based on what we're going to do.
+
+    set options [list]
+    switch $do_what {
+	"compile" {
+	    set compile_type "assembly"
+	    set output_file "[file rootname [file tail $prog]].s"
+	}
+	"link" {
+	    set compile_type "executable"
+	    set output_file "[file rootname [file tail $prog]].exe"
+	    # The following line is needed for targets like the i960 where
+	    # the default output file is b.out.  Sigh.
+	}
+	"run" {
+	    set compile_type "executable"
+	    # FIXME: "./" is to cope with "." not being in $PATH.
+	    # Should this be handled elsewhere?
+	    # YES.
+	    set output_file "./[file rootname [file tail $prog]].exe"
+	    # 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;
+	}
+	default {
+	    perror "$do_what: not a valid dg-do keyword"
+	    return ""
+	}
+    }
+
+    if { $extra_tool_flags != "" } {
+	lappend options "additional_flags=$extra_tool_flags"
+    }
+
+    set comp_output [libffi_target_compile "$prog" "$output_file" "$compile_type" $options];
+
+
+    return [list $comp_output $output_file]
+}
+
+
+proc libffi-dg-test { prog do_what extra_tool_flags } {
+    return [libffi-dg-test-1 target_compile $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
+    return $text
+}
+
+proc libffi-init { args } {
+    global gluefile wrap_flags;
+    global srcdir
+    global blddirffi
+    global objdir
+    global TOOL_OPTIONS
+    global tool
+    global libffi_include
+    global libffi_link_flags
+    global tool_root_dir
+    global ld_library_path
+    global compiler_vendor
+
+    if ![info exists blddirffi] {
+	set blddirffi [pwd]/..
+    }
+
+    verbose "libffi $blddirffi"
+
+    # Which compiler are we building with?
+    if { [string match $compiler_vendor "gnu"] } {
+        set gccdir [lookfor_file $tool_root_dir gcc/libgcc.a]
+        if {$gccdir != ""} {
+	    set gccdir [file dirname $gccdir]
+        }
+        verbose "gccdir $gccdir"
+
+        set ld_library_path "."
+        append ld_library_path ":${gccdir}"
+
+        set compiler "${gccdir}/xgcc"
+        if { [is_remote host] == 0 && [which $compiler] != 0 } {
+	    foreach i "[exec $compiler --print-multi-lib]" {
+	        set mldir ""
+	        regexp -- "\[a-z0-9=_/\.-\]*;" $i mldir
+	        set mldir [string trimright $mldir "\;@"]
+	        if { "$mldir" == "." } {
+		    continue
+	        }
+	        if { [llength [glob -nocomplain ${gccdir}/${mldir}/libgcc_s*.so.*]] >= 1 } {
+		    append ld_library_path ":${gccdir}/${mldir}"
+	        }
+	    }
+        }
+    }
+
+    # add the library path for libffi.
+    append ld_library_path ":${blddirffi}/.libs"
+
+    verbose "ld_library_path: $ld_library_path"
+
+    # Point to the Libffi headers in libffi.
+    set libffi_include "${blddirffi}/include"
+    verbose "libffi_include $libffi_include"
+
+    set libffi_dir  "${blddirffi}/.libs"
+    verbose "libffi_dir $libffi_dir"
+    if { $libffi_dir != "" } {
+	set libffi_dir [file dirname ${libffi_dir}]
+	set libffi_link_flags "-L${libffi_dir}/.libs"
+    }
+
+    set_ld_library_path_env_vars
+    libffi_maybe_build_wrapper "${objdir}/testglue.o"
+}
+
+proc libffi_exit { } {
+    global gluefile;
+
+    if [info exists gluefile] {
+	file_on_build delete $gluefile;
+	unset gluefile;
+    }
+}
+
+proc libffi_target_compile { source dest type options } {
+    global gluefile wrap_flags;
+    global srcdir
+    global blddirffi
+    global TOOL_OPTIONS
+    global libffi_link_flags
+    global libffi_include
+    global target_triplet
+    global compiler_vendor
+
+    if { [target_info needs_status_wrapper]!="" && [info exists gluefile] } {
+	lappend options "libs=${gluefile}"
+	lappend options "ldflags=$wrap_flags"
+    }
+
+    # TOOL_OPTIONS must come first, so that it doesn't override testcase
+    # specific options.
+    if [info exists TOOL_OPTIONS] {
+	lappend  options "additional_flags=$TOOL_OPTIONS"
+    }
+
+    # search for ffi_mips.h in srcdir, too
+    lappend options "additional_flags=-I${libffi_include} -I${srcdir}/../include  -I${libffi_include}/.."
+    lappend options "additional_flags=${libffi_link_flags}"
+
+    # Darwin needs a stack execution allowed flag.
+
+    if { [istarget "*-*-darwin9*"] || [istarget "*-*-darwin1*"]
+	 || [istarget "*-*-darwin2*"] } {
+	# lappend options "additional_flags=-Wl,-allow_stack_execute"
+        lappend options "additional_flags=-Wno-unused-command-line-argument"
+    }
+
+    # If you're building the compiler with --prefix set to a place
+    # where it's not yet installed, then the linker won't be able to
+    # find the libgcc used by libffi.dylib.  We could pass the
+    # -dylib_file option, but that's complicated, and it's much easier
+    # to just make the linker find libgcc using -L options.
+    if { [string match "*-*-darwin*" $target_triplet] } {
+	lappend options "libs= -shared-libgcc"
+    }
+
+    if { [string match "*-*-openbsd*" $target_triplet] } {
+	lappend options "libs= -lpthread"
+    }
+
+    lappend options "libs= -lffi"
+
+    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++"
+            if { [string match "*-*-darwin*" $target_triplet] } {
+                lappend options "libs= -lc++"
+            }
+        }
+
+        if { [string match "arc*-*-linux*" $target_triplet] } {
+            lappend options "libs= -lpthread"
+        }
+    }
+
+    verbose "options: $options"
+    return [target_compile $source $dest $type $options]
+}
+
+# TEST should be a preprocessor condition.  Returns true if it holds.
+proc libffi_feature_test { test } {
+    set src "ffitest[pid].c"
+
+    set f [open $src "w"]
+    puts $f "#include <ffi.h>"
+    puts $f $test
+    puts $f "/* OK */"
+    puts $f "#else"
+    puts $f "# error Failed $test"
+    puts $f "#endif"
+    close $f
+
+    set lines [libffi_target_compile $src /dev/null assembly ""]
+    file delete $src
+
+    return [string match "" $lines]
+}
+
+# Utility routines.
+
+#
+# search_for -- looks for a string match in a file
+#
+proc search_for { file pattern } {
+    set fd [open $file r]
+    while { [gets $fd cur_line]>=0 } {
+	if [string match "*$pattern*" $cur_line] then {
+	    close $fd
+	    return 1
+	}
+    }
+    close $fd
+    return 0
+}
+
+# Modified dg-runtest that can cycle through a list of optimization options
+# as c-torture does.
+proc libffi-dg-runtest { testcases default-extra-flags } {
+    global runtests
+
+    foreach test $testcases {
+	# If we're only testing specific files and this isn't one of
+	# them, skip it.
+	if ![runtest_file_p $runtests $test] {
+	    continue
+	}
+
+	# Look for a loop within the source code - if we don't find one,
+	# don't pass -funroll[-all]-loops.
+	global torture_with_loops torture_without_loops
+	if [expr [search_for $test "for*("]+[search_for $test "while*("]] {
+	    set option_list $torture_with_loops
+	} else {
+	    set option_list $torture_without_loops
+	}
+
+	set nshort [file tail [file dirname $test]]/[file tail $test]
+
+	foreach flags $option_list {
+	    verbose "Testing $nshort, $flags" 1
+	    dg-test $test $flags ${default-extra-flags}
+	}
+    }
+}
+
+proc run-many-tests { testcases extra_flags } {
+    global compiler_vendor
+    global has_gccbug
+    global env
+    switch $compiler_vendor {
+      "clang" {
+        set common "-W -Wall"
+        if [info exists env(LIBFFI_TEST_OPTIMIZATION)] {
+	  set optimizations [ list $env(LIBFFI_TEST_OPTIMIZATION) ]
+        } else {
+          set optimizations { "-O0" "-O2" }
+        }
+      }
+      "gnu" {
+        set common "-W -Wall -Wno-psabi"
+        if [info exists env(LIBFFI_TEST_OPTIMIZATION)] {
+	  set optimizations [ list $env(LIBFFI_TEST_OPTIMIZATION) ]
+        } else {
+          set optimizations { "-O0" "-O2" }
+        }
+      }
+      default {
+        # Assume we are using the vendor compiler.
+        set common ""
+        if [info exists env(LIBFFI_TEST_OPTIMIZATION)] {
+	  set optimizations [ list $env(LIBFFI_TEST_OPTIMIZATION) ]
+        } else {
+          set optimizations { "" }
+        }
+      }
+    }
+
+    info exists env(LD_LIBRARY_PATH)
+
+    set targetabis { "" }
+    if [string match $compiler_vendor "gnu"] {
+        if [libffi_feature_test "#ifdef __i386__"] {
+            set targetabis {
+                ""
+                "-DABI_NUM=FFI_STDCALL -DABI_ATTR=__STDCALL__"
+                "-DABI_NUM=FFI_THISCALL -DABI_ATTR=__THISCALL__"
+                "-DABI_NUM=FFI_FASTCALL -DABI_ATTR=__FASTCALL__"
+            }
+        } elseif { [istarget "x86_64-*-*"] \
+		   && [libffi_feature_test "#if !defined __ILP32__  \
+						&& !defined __i386__"] } {
+            set targetabis {
+                ""
+                "-DABI_NUM=FFI_GNUW64 -DABI_ATTR=__MSABI__"
+            }
+        }
+    }
+
+    set common [ concat $common $extra_flags ]
+    foreach test $testcases {
+        set testname [file tail $test]
+        if [search_for $test "ABI_NUM"] {
+            set abis $targetabis
+        } else {
+            set abis { "" }
+        }
+        foreach opt $optimizations {
+            foreach abi $abis {
+                set options [concat $common $opt $abi]
+		set has_gccbug false;
+		if { [string match $compiler_vendor "gnu"] \
+			 && [string match "*MSABI*" $abi] \
+			 && ( ( [string match "*DGTEST=57 *" $common] \
+				    && [string match "*call.c*" $testname] ) \
+				  || ( [string match "*DGTEST=54 *" $common] \
+					   && [string match "*callback*" $testname] ) \
+				  || [string match "*DGTEST=55 *" $common] \
+				  || [string match "*DGTEST=56 *" $common] ) } then {
+		    if [libffi_feature_test "#if (__GNUC__ < 9) || ((__GNUC__ == 9) && (__GNUC_MINOR__ < 3))"] {
+			set has_gccbug true;
+		    }
+		}
+		verbose "Testing $testname, $options" 1
+		verbose "has_gccbug = $has_gccbug" 1
+		dg-test $test $options ""
+            }
+        }
+    }
+}
+
+# Like check_conditional_xfail, but callable from a dg test.
+
+proc dg-xfail-if { args } {
+    set args [lreplace $args 0 0]
+    set selector "target [join [lindex $args 1]]"
+    if { [dg-process-target $selector] == "S" } {
+	global compiler_conditional_xfail_data
+	set compiler_conditional_xfail_data $args
+    }
+}
+
+proc check-flags { args } {
+
+    # The args are within another list; pull them out.
+    set args [lindex $args 0]
+
+    # The next two arguments are optional.  If they were not specified,
+    # use the defaults.
+    if { [llength $args] == 2 } {
+	lappend $args [list "*"]
+    }
+    if { [llength $args] == 3 } {
+	lappend $args [list ""]
+    }
+
+    # If the option strings are the defaults, or the same as the
+    # defaults, there is no need to call check_conditional_xfail to
+    # compare them to the actual options.
+    if { [string compare [lindex $args 2] "*"] == 0
+	 && [string compare [lindex $args 3] "" ] == 0 } {
+	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.
+	set result [check_conditional_xfail [lreplace $args 1 1 "*-*-*"]]
+    }
+
+    return $result
+}
+
+proc dg-skip-if { args } {
+    # Verify the number of arguments.  The last two are optional.
+    set args [lreplace $args 0 0]
+    if { [llength $args] < 2 || [llength $args] > 4 } {
+        error "dg-skip-if 2: need 2, 3, or 4 arguments"
+    }
+
+    # Don't bother if we're already skipping the test.
+    upvar dg-do-what dg-do-what
+    if { [lindex ${dg-do-what} 1] == "N" } {
+      return
+    }
+
+    set selector [list target [lindex $args 1]]
+    if { [dg-process-target $selector] == "S" } {
+        if [check-flags $args] {
+            upvar dg-do-what dg-do-what
+            set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"]
+        }
+    }
+}
+
+# We need to make sure that additional_files and additional_sources
+# are both cleared out after every test.  It is not enough to clear
+# them out *before* the next test run because gcc-target-compile gets
+# run directly from some .exp files (outside of any test).  (Those
+# uses should eventually be eliminated.)
+
+# Because the DG framework doesn't provide a hook that is run at the
+# end of a test, we must replace dg-test with a wrapper.
+
+if { [info procs saved-dg-test] == [list] } {
+    rename dg-test saved-dg-test
+
+    proc dg-test { args } {
+	global additional_files
+	global additional_sources
+	global errorInfo
+
+	if { [ catch { eval saved-dg-test $args } errmsg ] } {
+	    set saved_info $errorInfo
+	    set additional_files ""
+	    set additional_sources ""
+	    error $errmsg $saved_info
+	}
+	set additional_files ""
+	set additional_sources ""
+    }
+}
+
+# Local Variables:
+# tcl-indent-level:4
+# End:

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/lib/target-libpath.exp

@@ -0,0 +1,283 @@
+# Copyright (C) 2004, 2005, 2007 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
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# This file was contributed by John David Anglin (dave.anglin@nrc-cnrc.gc.ca)
+
+set orig_environment_saved 0
+set orig_ld_library_path_saved 0
+set orig_ld_run_path_saved 0
+set orig_shlib_path_saved 0
+set orig_ld_libraryn32_path_saved 0
+set orig_ld_library64_path_saved 0
+set orig_ld_library_path_32_saved 0
+set orig_ld_library_path_64_saved 0
+set orig_dyld_library_path_saved 0
+set orig_path_saved 0
+
+#######################################
+# proc set_ld_library_path_env_vars { }
+#######################################
+
+proc set_ld_library_path_env_vars { } {
+  global ld_library_path
+  global orig_environment_saved
+  global orig_ld_library_path_saved
+  global orig_ld_run_path_saved
+  global orig_shlib_path_saved
+  global orig_ld_libraryn32_path_saved
+  global orig_ld_library64_path_saved
+  global orig_ld_library_path_32_saved
+  global orig_ld_library_path_64_saved
+  global orig_dyld_library_path_saved
+  global orig_path_saved
+  global orig_ld_library_path
+  global orig_ld_run_path
+  global orig_shlib_path
+  global orig_ld_libraryn32_path
+  global orig_ld_library64_path
+  global orig_ld_library_path_32
+  global orig_ld_library_path_64
+  global orig_dyld_library_path
+  global orig_path
+  global GCC_EXEC_PREFIX
+
+  # Set the relocated compiler prefix, but only if the user hasn't specified one.
+  if { [info exists GCC_EXEC_PREFIX] && ![info exists env(GCC_EXEC_PREFIX)] } {
+    setenv GCC_EXEC_PREFIX "$GCC_EXEC_PREFIX"
+  }
+
+  # Setting the ld library path causes trouble when testing cross-compilers.
+  if { [is_remote target] } {
+    return
+  }
+
+  if { $orig_environment_saved == 0 } {
+    global env
+
+    set orig_environment_saved 1
+
+    # Save the original environment.
+    if [info exists env(LD_LIBRARY_PATH)] {
+      set orig_ld_library_path "$env(LD_LIBRARY_PATH)"
+      set orig_ld_library_path_saved 1
+    }
+    if [info exists env(LD_RUN_PATH)] {
+      set orig_ld_run_path "$env(LD_RUN_PATH)"
+      set orig_ld_run_path_saved 1
+    }
+    if [info exists env(SHLIB_PATH)] {
+      set orig_shlib_path "$env(SHLIB_PATH)"
+      set orig_shlib_path_saved 1
+    }
+    if [info exists env(LD_LIBRARYN32_PATH)] {
+      set orig_ld_libraryn32_path "$env(LD_LIBRARYN32_PATH)"
+      set orig_ld_libraryn32_path_saved 1
+    }
+    if [info exists env(LD_LIBRARY64_PATH)] {
+      set orig_ld_library64_path "$env(LD_LIBRARY64_PATH)"
+      set orig_ld_library64_path_saved 1
+    }
+    if [info exists env(LD_LIBRARY_PATH_32)] {
+      set orig_ld_library_path_32 "$env(LD_LIBRARY_PATH_32)"
+      set orig_ld_library_path_32_saved 1
+    }
+    if [info exists env(LD_LIBRARY_PATH_64)] {
+      set orig_ld_library_path_64 "$env(LD_LIBRARY_PATH_64)"
+      set orig_ld_library_path_64_saved 1
+    }
+    if [info exists env(DYLD_LIBRARY_PATH)] {
+      set orig_dyld_library_path "$env(DYLD_LIBRARY_PATH)"
+      set orig_dyld_library_path_saved 1
+    }
+    if [info exists env(PATH)] {
+      set orig_path "$env(PATH)"
+      set orig_path_saved 1
+    }
+  }
+
+  # We need to set ld library path in the environment.  Currently,
+  # unix.exp doesn't set the environment correctly for all systems.
+  # It only sets SHLIB_PATH and LD_LIBRARY_PATH when it executes a
+  # program.  We also need the environment set for compilations, etc.
+  #
+  # On IRIX 6, we have to set variables akin to LD_LIBRARY_PATH, but
+  # called LD_LIBRARYN32_PATH (for the N32 ABI) and LD_LIBRARY64_PATH
+  # (for the 64-bit ABI).  The same applies to Darwin (DYLD_LIBRARY_PATH),
+  # Solaris 32 bit (LD_LIBRARY_PATH_32), Solaris 64 bit (LD_LIBRARY_PATH_64),
+  # and HP-UX (SHLIB_PATH).  In some cases, the variables are independent
+  # of LD_LIBRARY_PATH, and in other cases LD_LIBRARY_PATH is used if the
+  # variable is not defined.
+  #
+  # Doing this is somewhat of a hack as ld_library_path gets repeated in
+  # SHLIB_PATH and LD_LIBRARY_PATH when unix_load sets these variables.
+  if { $orig_ld_library_path_saved } {
+    setenv LD_LIBRARY_PATH "$ld_library_path:$orig_ld_library_path"
+  } else {
+    setenv LD_LIBRARY_PATH "$ld_library_path"
+  }
+  if { $orig_ld_run_path_saved } {
+    setenv LD_RUN_PATH "$ld_library_path:$orig_ld_run_path"
+  } else {
+    setenv LD_RUN_PATH "$ld_library_path"
+  }
+  # The default shared library dynamic path search for 64-bit
+  # HP-UX executables searches LD_LIBRARY_PATH before SHLIB_PATH.
+  # LD_LIBRARY_PATH isn't used for 32-bit executables.  Thus, we
+  # set LD_LIBRARY_PATH and SHLIB_PATH as if they were independent.
+  if { $orig_shlib_path_saved } {
+    setenv SHLIB_PATH "$ld_library_path:$orig_shlib_path"
+  } else {
+    setenv SHLIB_PATH "$ld_library_path"
+  }
+  if { $orig_ld_libraryn32_path_saved } {
+    setenv LD_LIBRARYN32_PATH "$ld_library_path:$orig_ld_libraryn32_path"
+  } elseif { $orig_ld_library_path_saved } {
+    setenv LD_LIBRARYN32_PATH "$ld_library_path:$orig_ld_library_path"
+  } else {
+    setenv LD_LIBRARYN32_PATH "$ld_library_path"
+  }
+  if { $orig_ld_library64_path_saved } {
+    setenv LD_LIBRARY64_PATH "$ld_library_path:$orig_ld_library64_path"
+  } elseif { $orig_ld_library_path_saved } {
+    setenv LD_LIBRARY64_PATH "$ld_library_path:$orig_ld_library_path"
+  } else {
+    setenv LD_LIBRARY64_PATH "$ld_library_path"
+  }
+  if { $orig_ld_library_path_32_saved } {
+    setenv LD_LIBRARY_PATH_32 "$ld_library_path:$orig_ld_library_path_32"
+  } elseif { $orig_ld_library_path_saved } {
+    setenv LD_LIBRARY_PATH_32 "$ld_library_path:$orig_ld_library_path"
+  } else {
+    setenv LD_LIBRARY_PATH_32 "$ld_library_path"
+  }
+  if { $orig_ld_library_path_64_saved } {
+    setenv LD_LIBRARY_PATH_64 "$ld_library_path:$orig_ld_library_path_64"
+  } elseif { $orig_ld_library_path_saved } {
+    setenv LD_LIBRARY_PATH_64 "$ld_library_path:$orig_ld_library_path"
+  } else {
+    setenv LD_LIBRARY_PATH_64 "$ld_library_path"
+  }
+  if { $orig_dyld_library_path_saved } {
+    setenv DYLD_LIBRARY_PATH "$ld_library_path:$orig_dyld_library_path"
+  } else {
+    setenv DYLD_LIBRARY_PATH "$ld_library_path"
+  }
+  if { [istarget *-*-cygwin*] || [ istarget *-*-msys* ] || [istarget *-*-mingw*] } {
+    if { $orig_path_saved } {
+      setenv PATH "$ld_library_path:$orig_path"
+    } else {
+      setenv PATH "$ld_library_path"
+    }
+  }
+
+  verbose -log "set_ld_library_path_env_vars: ld_library_path=$ld_library_path"
+}
+
+#######################################
+# proc restore_ld_library_path_env_vars { }
+#######################################
+
+proc restore_ld_library_path_env_vars { } {
+  global orig_environment_saved
+  global orig_ld_library_path_saved
+  global orig_ld_run_path_saved
+  global orig_shlib_path_saved
+  global orig_ld_libraryn32_path_saved
+  global orig_ld_library64_path_saved
+  global orig_ld_library_path_32_saved
+  global orig_ld_library_path_64_saved
+  global orig_dyld_library_path_saved
+  global orig_path_saved
+  global orig_ld_library_path
+  global orig_ld_run_path
+  global orig_shlib_path
+  global orig_ld_libraryn32_path
+  global orig_ld_library64_path
+  global orig_ld_library_path_32
+  global orig_ld_library_path_64
+  global orig_dyld_library_path
+  global orig_path
+
+  if { $orig_environment_saved == 0 } {
+    return
+  }
+
+  if { $orig_ld_library_path_saved } {
+    setenv LD_LIBRARY_PATH "$orig_ld_library_path"
+  } elseif [info exists env(LD_LIBRARY_PATH)] {
+    unsetenv LD_LIBRARY_PATH
+  }
+  if { $orig_ld_run_path_saved } {
+    setenv LD_RUN_PATH "$orig_ld_run_path"
+  } elseif [info exists env(LD_RUN_PATH)] {
+    unsetenv LD_RUN_PATH
+  }
+  if { $orig_shlib_path_saved } {
+    setenv SHLIB_PATH "$orig_shlib_path"
+  } elseif [info exists env(SHLIB_PATH)] {
+    unsetenv SHLIB_PATH
+  }
+  if { $orig_ld_libraryn32_path_saved } {
+    setenv LD_LIBRARYN32_PATH "$orig_ld_libraryn32_path"
+  } elseif [info exists env(LD_LIBRARYN32_PATH)] {
+    unsetenv LD_LIBRARYN32_PATH
+  }
+  if { $orig_ld_library64_path_saved } {
+    setenv LD_LIBRARY64_PATH "$orig_ld_library64_path"
+  } elseif [info exists env(LD_LIBRARY64_PATH)] {
+    unsetenv LD_LIBRARY64_PATH
+  }
+  if { $orig_ld_library_path_32_saved } {
+    setenv LD_LIBRARY_PATH_32 "$orig_ld_library_path_32"
+  } elseif [info exists env(LD_LIBRARY_PATH_32)] {
+    unsetenv LD_LIBRARY_PATH_32
+  }
+  if { $orig_ld_library_path_64_saved } {
+    setenv LD_LIBRARY_PATH_64 "$orig_ld_library_path_64"
+  } elseif [info exists env(LD_LIBRARY_PATH_64)] {
+    unsetenv LD_LIBRARY_PATH_64
+  }
+  if { $orig_dyld_library_path_saved } {
+    setenv DYLD_LIBRARY_PATH "$orig_dyld_library_path"
+  } elseif [info exists env(DYLD_LIBRARY_PATH)] {
+    unsetenv DYLD_LIBRARY_PATH
+  }
+  if { $orig_path_saved } {
+    setenv PATH "$orig_path"
+  } elseif [info exists env(PATH)] {
+    unsetenv PATH
+  }
+}
+
+#######################################
+# proc get_shlib_extension { }
+#######################################
+
+proc get_shlib_extension { } {
+    global shlib_ext
+
+    if { [ istarget *-*-darwin* ] } {
+	set shlib_ext "dylib"
+    } elseif { [ istarget *-*-cygwin* ] || [ istarget *-*-msys* ] || [ istarget *-*-mingw* ] } {
+	set shlib_ext "dll"
+    } elseif { [ istarget hppa*-*-hpux* ] } {
+	set shlib_ext "sl"
+    } else {
+	set shlib_ext "so"
+    }
+    return $shlib_ext
+}
+

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/lib/wrapper.exp

@@ -0,0 +1,45 @@
+#   Copyright (C) 2004, 2007 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
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# This file contains GCC-specifics for status wrappers for test programs.
+
+# ${tool}_maybe_build_wrapper -- Build wrapper object if the target
+# needs it.  FILENAME is the path to the wrapper file.  If there are
+# additional arguments, they are command-line options to provide to
+# the compiler when compiling FILENAME.
+
+proc ${tool}_maybe_build_wrapper { filename args } {
+    global gluefile wrap_flags
+
+    if { [target_info needs_status_wrapper] != "" \
+ 	 && [target_info needs_status_wrapper] != "0" \
+	 && ![info exists gluefile] } {
+	set saved_wrap_compile_flags [target_info wrap_compile_flags]
+	set flags [join $args " "]
+	# The wrapper code may contain code that gcc objects on.  This
+	# became true for dejagnu-1.4.4.  The set of warnings and code
+	# that gcc objects on may change, so just make sure -w is always
+	# passed to turn off all warnings.
+	set_currtarget_info wrap_compile_flags \
+	    "$saved_wrap_compile_flags -w $flags"
+	set result [build_wrapper $filename]
+	set_currtarget_info wrap_compile_flags "$saved_wrap_compile_flags"
+	if { $result != "" } {
+	    set gluefile [lindex $result 0]
+	    set wrap_flags [lindex $result 1]
+	}
+    }
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.bhaible/Makefile

@@ -0,0 +1,28 @@
+CC = gcc
+CFLAGS = -O2 -Wall
+prefix =
+includedir = $(prefix)/include
+libdir = $(prefix)/lib
+CPPFLAGS = -I$(includedir)
+LDFLAGS = -L$(libdir) -Wl,-rpath,$(libdir)
+
+all: check-call check-callback
+
+test-call: test-call.c testcases.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o test-call test-call.c -lffi
+
+test-callback: test-callback.c testcases.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o test-callback test-callback.c -lffi
+
+check-call: test-call
+	./test-call > test-call.out
+	LC_ALL=C uniq -u < test-call.out > failed-call
+	test '!' -s failed-call
+
+check-callback: test-callback
+	./test-callback > test-callback.out
+	LC_ALL=C uniq -u < test-callback.out > failed-callback
+	test '!' -s failed-callback
+
+clean:
+	rm -f test-call test-callback test-call.out test-callback.out failed-call failed-callback

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.bhaible/README

@@ -0,0 +1,78 @@
+This package contains a test suite for libffi.
+
+This test suite can be compiled with a C compiler. No need for 'expect'
+or some other package that is often not installed.
+
+The test suite consists of 81 C functions, each with a different signature.
+* test-call verifies that calling each function directly produces the same
+  results as calling the function indirectly through 'ffi_call'.
+* test-callback verifies that calling each function directly produces the same
+  results as calling a function that is a callback (object build by
+  'ffi_prep_closure_loc') and simulates the original function.
+
+Each direct or indirect invocation should produce one line of output to
+stdout. A correct output consists of paired lines, such as
+
+void f(void):
+void f(void):
+int f(void):->99
+int f(void):->99
+int f(int):(1)->2
+int f(int):(1)->2
+int f(2*int):(1,2)->3
+int f(2*int):(1,2)->3
+...
+
+The Makefile then creates two files:
+* failed-call, which consists of the non-paired lines of output of
+  'test-call',
+* failed-callback, which consists of the non-paired lines of output of
+  'test-callback'.
+
+The test suite passes if both failed-call and failed-callback come out
+as empty.
+
+
+How to use the test suite
+-------------------------
+
+1. Modify the Makefile's variables
+   prefix = the directory in which libffi was installed
+   CC = the C compiler, often with options such as "-m32" or "-m64"
+        that enforce a certain ABI,
+   CFLAGS = optimization options (need to change them only for non-GCC
+            compilers)
+2. Run "make". If it fails already in "test-call", run also
+   "make check-callback".
+3. If this failed, inspect the output files.
+
+
+How to interpret the results
+----------------------------
+
+The failed-call and failed-callback files consist of paired lines:
+The first line is the result of the direct invocation.
+The second line is the result of invocation through libffi.
+
+For example, this output
+
+uchar f(uchar,ushort,uint,ulong):(97,2,3,4)->255
+uchar f(uchar,ushort,uint,ulong):(97,2,3,4)->0
+
+indicates that the arguments were passed correctly, but the return
+value came out wrong.
+
+And this output
+
+float f(17*float,3*int,L):(0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,6,7,8,561,1105,1729,2465,2821,6601)->15319.1
+float f(17*float,3*int,L):(0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,-140443648,10,268042216,-72537980,-140443648,-140443648,-140443648,-140443648,-140443648)->-6.47158e+08
+
+indicates that integer arguments that come after 17 floating-point arguments
+were not passed correctly.
+
+
+Credits
+-------
+
+The test suite is based on the one of GNU libffcall-2.0.
+Authors: Bill Triggs, Bruno Haible

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.bhaible/alignof.h

@@ -0,0 +1,50 @@
+/* Determine alignment of types.
+   Copyright (C) 2003-2004, 2006, 2009-2017 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
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, see <https://www.gnu.org/licenses/>.  */
+
+#ifndef _ALIGNOF_H
+#define _ALIGNOF_H
+
+#include <stddef.h>
+
+/* alignof_slot (TYPE)
+   Determine the alignment of a structure slot (field) of a given type,
+   at compile time.  Note that the result depends on the ABI.
+   This is the same as alignof (TYPE) and _Alignof (TYPE), defined in
+   <stdalign.h> if __alignof_is_defined is 1.
+   Note: The result cannot be used as a value for an 'enum' constant,
+   due to bugs in HP-UX 10.20 cc and AIX 3.2.5 xlc.  */
+#if defined __cplusplus
+  template <class type> struct alignof_helper { char __slot1; type __slot2; };
+# define alignof_slot(type) offsetof (alignof_helper<type>, __slot2)
+#else
+# define alignof_slot(type) offsetof (struct { char __slot1; type __slot2; }, __slot2)
+#endif
+
+/* alignof_type (TYPE)
+   Determine the good alignment of an object of the given type at compile time.
+   Note that this is not necessarily the same as alignof_slot(type).
+   For example, with GNU C on x86 platforms: alignof_type(double) = 8, but
+   - when -malign-double is not specified:  alignof_slot(double) = 4,
+   - when -malign-double is specified:      alignof_slot(double) = 8.
+   Note: The result cannot be used as a value for an 'enum' constant,
+   due to bugs in HP-UX 10.20 cc and AIX 3.2.5 xlc.  */
+#if defined __GNUC__ || defined __IBM__ALIGNOF__
+# define alignof_type __alignof__
+#else
+# define alignof_type alignof_slot
+#endif
+
+#endif /* _ALIGNOF_H */

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.bhaible/bhaible.exp

@@ -0,0 +1,63 @@
+# Copyright (C) 2003, 2006, 2009, 2010, 2014, 2018 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
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+dg-init
+libffi-init
+
+global srcdir subdir
+global compiler_vendor
+
+# The conversion of this testsuite into a dejagnu compatible testsuite
+# was done in a pretty lazy fashion, and requires the use of compiler
+# flags to disable warnings for now.
+if { [string match $compiler_vendor "gnu"] } {
+    set warning_options "-Wno-unused-variable -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-uninitialized";
+}
+if { [string match $compiler_vendor "microsoft"] } {
+    # -wd4996  suggest use of vsprintf_s instead of vsprintf
+    # -wd4116  unnamed type definition
+    # -wd4101  unreferenced local variable
+    # -wd4244  warning about implicit double to float conversion
+    set warning_options "-wd4996 -wd4116 -wd4101 -wd4244";
+}
+if { ![string match $compiler_vendor "microsoft"] && ![string match $compiler_vendor "gnu"] } {
+    set warning_options "-Wno-unused-variable -Wno-unused-parameter -Wno-uninitialized";
+}
+
+
+set tlist [lsort [glob -nocomplain -- $srcdir/$subdir/test-call.c]]
+
+for {set i 1} {$i < 82} {incr i} {
+    run-many-tests $tlist [format "-DDGTEST=%d %s" $i $warning_options]
+}
+
+set tlist [lsort [glob -nocomplain -- $srcdir/$subdir/test-callback.c]]
+
+for {set i 1} {$i < 81} {incr i} {
+    if { [libffi_feature_test "#if FFI_CLOSURES"] } {
+        run-many-tests $tlist [format "-DDGTEST=%d %s" $i $warning_options]
+    } else {
+        foreach test $tlist {
+            unsupported [format "%s -DDGTEST=%d %s" $test $i $warning_options]
+        }
+    }
+}
+
+dg-finish
+
+# Local Variables:
+# tcl-indent-level:4
+# End:

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.bhaible/test-call.c

@@ -0,0 +1,1746 @@
+/**
+  Copyright 1993 Bill Triggs <Bill.Triggs@inrialpes.fr>
+  Copyright 1995-2017 Bruno Haible <bruno@clisp.org>
+
+  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
+  the Free Software Foundation; either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+**/
+
+/* { dg-do run { xfail gccbug } } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ffi.h>
+#include "alignof.h"
+#include <stdarg.h>
+
+/* libffi testsuite local changes -------------------------------- */
+#ifdef DGTEST
+/* Redefine exit(1) as a test failure */
+#define exit(V) (void)((V) ? (abort(), 1) : exit(0))
+int count = 0;
+char rbuf1[2048];
+char rbuf2[2048];
+int _fprintf(FILE *stream, const char *format, ...)
+{
+  va_list args;
+  va_start(args, format);
+
+  switch (count++)
+    {
+    case 0:
+    case 1:
+      vsprintf(&rbuf1[strlen(rbuf1)], format, args);
+      break;
+    case 2:
+      printf("%s", rbuf1);
+      vsprintf(rbuf2, format, args);
+      break;
+    case 3:
+      vsprintf(&rbuf2[strlen(rbuf2)], format, args);
+      printf("%s", rbuf2);
+      fflush (stdout);
+      if (strcmp (rbuf1, rbuf2)) abort();
+      break;
+    }
+
+  va_end(args);
+
+  return 0;
+}
+#define fprintf _fprintf
+#endif
+/* --------------------------------------------------------------- */
+
+#include "testcases.c"
+
+#ifndef ABI_NUM
+#define ABI_NUM FFI_DEFAULT_ABI
+#endif
+
+/* Definitions that ought to be part of libffi. */
+static ffi_type ffi_type_char;
+#define ffi_type_slonglong ffi_type_sint64
+#define ffi_type_ulonglong ffi_type_uint64
+
+/* libffi does not support arrays inside structs. */
+#define SKIP_EXTRA_STRUCTS
+
+#define FFI_PREP_CIF(cif,argtypes,rettype) \
+  if (ffi_prep_cif(&(cif),ABI_NUM,sizeof(argtypes)/sizeof(argtypes[0]),&rettype,argtypes) != FFI_OK) abort()
+#define FFI_PREP_CIF_NOARGS(cif,rettype) \
+  if (ffi_prep_cif(&(cif),ABI_NUM,0,&rettype,NULL) != FFI_OK) abort()
+#define FFI_CALL(cif,fn,args,retaddr) \
+  ffi_call(&(cif),(void(*)(void))(fn),retaddr,args)
+
+long clear_traces_i (long a, long b, long c, long d, long e, long f, long g, long h,
+                     long i, long j, long k, long l, long m, long n, long o, long p)
+{ return 0; }
+float clear_traces_f (float a, float b, float c, float d, float e, float f, float g,
+                      float h, float i, float j, float k, float l, float m, float n,
+                      float o, float p)
+{ return 0.0; }
+double clear_traces_d (double a, double b, double c, double d, double e, double f, double g,
+                       double h, double i, double j, double k, double l, double m, double n,
+                       double o, double p)
+{ return 0.0; }
+J clear_traces_J (void)
+{ J j; j.l1 = j.l2 = 0; return j; }
+void clear_traces (void)
+{ clear_traces_i(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
+  clear_traces_f(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
+  clear_traces_d(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
+  clear_traces_J();
+}
+
+void
+  void_tests (void)
+{
+#if (!defined(DGTEST)) || DGTEST == 1  
+  v_v();
+  clear_traces();
+  {
+    ffi_cif cif;
+    FFI_PREP_CIF_NOARGS(cif,ffi_type_void);
+    {
+      FFI_CALL(cif,v_v,NULL,NULL);
+    }
+  }
+#endif  
+  return;
+}
+void
+  int_tests (void)
+{
+  int ir;
+  ffi_arg retvalue;
+#if (!defined(DGTEST)) || DGTEST == 2
+  ir = i_v();
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+  ir = 0; clear_traces();
+  {
+    ffi_cif cif;
+    FFI_PREP_CIF_NOARGS(cif,ffi_type_sint);
+    {
+      FFI_CALL(cif,i_v,NULL,&retvalue);
+      ir = retvalue;
+    }
+  }
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 3
+  ir = i_i(i1);
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+  ir = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
+    {
+      /*const*/ void* args[] = { &i1 };
+      FFI_CALL(cif,i_i,args,&retvalue);
+      ir = retvalue;
+    }
+  }
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 4
+  ir = i_i2(i1,i2);
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+  ir = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
+    {
+      /*const*/ void* args[] = { &i1, &i2 };
+      FFI_CALL(cif,i_i2,args,&retvalue);
+      ir = retvalue;
+    }
+  }
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 5
+  ir = i_i4(i1,i2,i3,i4);
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+  ir = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
+    {
+      /*const*/ void* args[] = { &i1, &i2, &i3, &i4 };
+      FFI_CALL(cif,i_i4,args,&retvalue);
+      ir = retvalue;
+    }
+  }
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 6
+  ir = i_i8(i1,i2,i3,i4,i5,i6,i7,i8);
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+  ir = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
+    {
+      /*const*/ void* args[] = { &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8 };
+      FFI_CALL(cif,i_i8,args,&retvalue);
+      ir = retvalue;
+    }
+  }
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 7
+  ir = i_i16(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+  ir = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
+    {
+      /*const*/ void* args[] = { &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8, &i9, &i10, &i11, &i12, &i13, &i14, &i15, &i16 };
+      FFI_CALL(cif,i_i16,args,&retvalue);
+      ir = retvalue;
+    }
+  }
+  fprintf(out,"->%d\n",ir);
+  fflush(out);
+#endif
+
+  return;
+}
+void
+  float_tests (void)
+{
+  float fr;
+
+#if (!defined(DGTEST)) || DGTEST == 8
+  fr = f_f(f1);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1 };
+      FFI_CALL(cif,f_f,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 9
+  fr = f_f2(f1,f2);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2 };
+      FFI_CALL(cif,f_f2,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 10
+  fr = f_f4(f1,f2,f3,f4);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4 };
+      FFI_CALL(cif,f_f4,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 11
+  fr = f_f8(f1,f2,f3,f4,f5,f6,f7,f8);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8 };
+      FFI_CALL(cif,f_f8,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 12
+  fr = f_f16(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9, &f10, &f11, &f12, &f13, &f14, &f15, &f16 };
+      FFI_CALL(cif,f_f16,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 13
+  fr = f_f24(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9, &f10, &f11, &f12, &f13, &f14, &f15, &f16, &f17, &f18, &f19, &f20, &f21, &f22, &f23, &f24 };
+      FFI_CALL(cif,f_f24,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+}
+void
+  double_tests (void)
+{
+  double dr;
+
+#if (!defined(DGTEST)) || DGTEST == 14
+  
+  dr = d_d(d1);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1 };
+      FFI_CALL(cif,d_d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 15
+  dr = d_d2(d1,d2);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2 };
+      FFI_CALL(cif,d_d2,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 16
+  dr = d_d4(d1,d2,d3,d4);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4 };
+      FFI_CALL(cif,d_d4,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 17
+  dr = d_d8(d1,d2,d3,d4,d5,d6,d7,d8);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8 };
+      FFI_CALL(cif,d_d8,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 18
+  dr = d_d16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9, &d10, &d11, &d12, &d13, &d14, &d15, &d16 };
+      FFI_CALL(cif,d_d16,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif  
+  return;
+}
+void
+  pointer_tests (void)
+{
+  void* vpr;
+
+#if (!defined(DGTEST)) || DGTEST == 19
+  vpr = vp_vpdpcpsp(&uc1,&d2,str3,&I4);
+  fprintf(out,"->0x%p\n",vpr);
+  fflush(out);
+  vpr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_pointer);
+    {
+      void* puc1 = &uc1;
+      void* pd2 = &d2;
+      void* pstr3 = str3;
+      void* pI4 = &I4;
+      /*const*/ void* args[] = { &puc1, &pd2, &pstr3, &pI4 };
+      FFI_CALL(cif,vp_vpdpcpsp,args,&vpr);
+    }
+  }
+  fprintf(out,"->0x%p\n",vpr);
+  fflush(out);
+#endif  
+  return;
+}
+void
+  mixed_number_tests (void)
+{
+  uchar ucr;
+  ushort usr;
+  float fr;
+  double dr;
+  long long llr;
+
+  /* Unsigned types.
+   */
+#if (!defined(DGTEST)) || DGTEST == 20
+  ucr = uc_ucsil(uc1, us2, ui3, ul4);
+  fprintf(out,"->%u\n",ucr);
+  fflush(out);
+  ucr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_uchar, &ffi_type_ushort, &ffi_type_uint, &ffi_type_ulong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_uchar);
+    {
+      ffi_arg r;
+      /*const*/ void* args[] = { &uc1, &us2, &ui3, &ul4 };
+      FFI_CALL(cif,uc_ucsil,args,&r);
+      ucr = (uchar) r;
+    }
+  }
+  fprintf(out,"->%u\n",ucr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 21
+  /* Mixed int & float types.
+   */
+  dr = d_iidd(i1,i2,d3,d4);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_double, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &i1, &i2, &d3, &d4 };
+      FFI_CALL(cif,d_iidd,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 22
+  dr = d_iiidi(i1,i2,i3,d4,i5);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &i1, &i2, &i3, &d4, &i5 };
+      FFI_CALL(cif,d_iiidi,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 23
+  dr = d_idid(i1,d2,i3,d4);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_double, &ffi_type_sint, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &i1, &d2, &i3, &d4 };
+      FFI_CALL(cif,d_idid,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 24
+  dr = d_fdi(f1,d2,i3);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &f1, &d2, &i3 };
+      FFI_CALL(cif,d_fdi,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 25
+  usr = us_cdcd(c1,d2,c3,d4);
+  fprintf(out,"->%u\n",usr);
+  fflush(out);
+  usr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_char, &ffi_type_double, &ffi_type_char, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_ushort);
+    {
+      ffi_arg rint;
+      /*const*/ void* args[] = { &c1, &d2, &c3, &d4 };
+      FFI_CALL(cif,us_cdcd,args,&rint);
+      usr = (ushort) rint;
+    }
+  }
+  fprintf(out,"->%u\n",usr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 26
+  /* Long long types.
+   */
+  llr = ll_iiilli(i1,i2,i3,ll1,i13);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_slonglong, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &i1, &i2, &i3, &ll1, &i13 };
+      FFI_CALL(cif,ll_iiilli,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 27
+  llr = ll_flli(f13,ll1,i13);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_slonglong, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &f13, &ll1, &i13 };
+      FFI_CALL(cif,ll_flli,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 28
+  fr = f_fi(f1,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &i9 };
+      FFI_CALL(cif,f_fi,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 29
+  fr = f_f2i(f1,f2,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &i9 };
+      FFI_CALL(cif,f_f2i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 30
+  fr = f_f3i(f1,f2,f3,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &i9 };
+      FFI_CALL(cif,f_f3i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 31
+  fr = f_f4i(f1,f2,f3,f4,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &i9 };
+      FFI_CALL(cif,f_f4i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 32
+  fr = f_f7i(f1,f2,f3,f4,f5,f6,f7,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &i9 };
+      FFI_CALL(cif,f_f7i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 33
+  fr = f_f8i(f1,f2,f3,f4,f5,f6,f7,f8,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &i9 };
+      FFI_CALL(cif,f_f8i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 34
+  fr = f_f12i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9, &f10, &f11, &f12, &i9 };
+      FFI_CALL(cif,f_f12i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 35
+  fr = f_f13i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9, &f10, &f11, &f12, &f13, &i9 };
+      FFI_CALL(cif,f_f13i,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 36
+  dr = d_di(d1,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &i9 };
+      FFI_CALL(cif,d_di,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 37
+  dr = d_d2i(d1,d2,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &i9 };
+      FFI_CALL(cif,d_d2i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 38
+  dr = d_d3i(d1,d2,d3,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &i9 };
+      FFI_CALL(cif,d_d3i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 39
+  dr = d_d4i(d1,d2,d3,d4,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &i9 };
+      FFI_CALL(cif,d_d4i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 40
+  dr = d_d7i(d1,d2,d3,d4,d5,d6,d7,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &i9 };
+      FFI_CALL(cif,d_d7i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 41
+  dr = d_d8i(d1,d2,d3,d4,d5,d6,d7,d8,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &i9 };
+      FFI_CALL(cif,d_d8i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 42
+  dr = d_d12i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9, &d10, &d11, &d12, &i9 };
+      FFI_CALL(cif,d_d12i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+
+#if (!defined(DGTEST)) || DGTEST == 43
+  dr = d_d13i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9, &d10, &d11, &d12, &d13, &i9 };
+      FFI_CALL(cif,d_d13i,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif  
+  return;
+}
+void
+  small_structure_return_tests (void)
+{
+#if (!defined(DGTEST)) || DGTEST == 44
+  {
+    Size1 r = S1_v();
+    fprintf(out,"->{%c}\n",r.x1);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size1_elements[] = { &ffi_type_char, NULL };
+      ffi_type ffi_type_Size1;
+      ffi_type_Size1.type = FFI_TYPE_STRUCT;
+      ffi_type_Size1.size = sizeof(Size1);
+      ffi_type_Size1.alignment = alignof_slot(Size1);
+      ffi_type_Size1.elements = ffi_type_Size1_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size1);
+      {
+        FFI_CALL(cif,S1_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c}\n",r.x1);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 45
+  {
+    Size2 r = S2_v();
+    fprintf(out,"->{%c%c}\n",r.x1,r.x2);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size2_elements[] = { &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size2;
+      ffi_type_Size2.type = FFI_TYPE_STRUCT;
+      ffi_type_Size2.size = sizeof(Size2);
+      ffi_type_Size2.alignment = alignof_slot(Size2);
+      ffi_type_Size2.elements = ffi_type_Size2_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size2);
+      {
+        FFI_CALL(cif,S2_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c}\n",r.x1,r.x2);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 46
+  {
+    Size3 r = S3_v();
+    fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size3_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size3;
+      ffi_type_Size3.type = FFI_TYPE_STRUCT;
+      ffi_type_Size3.size = sizeof(Size3);
+      ffi_type_Size3.alignment = alignof_slot(Size3);
+      ffi_type_Size3.elements = ffi_type_Size3_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size3);
+      {
+        FFI_CALL(cif,S3_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 47
+  {
+    Size4 r = S4_v();
+    fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size4_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size4;
+      ffi_type_Size4.type = FFI_TYPE_STRUCT;
+      ffi_type_Size4.size = sizeof(Size4);
+      ffi_type_Size4.alignment = alignof_slot(Size4);
+      ffi_type_Size4.elements = ffi_type_Size4_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size4);
+      {
+        FFI_CALL(cif,S4_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 48
+  {
+    Size7 r = S7_v();
+    fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size7_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size7;
+      ffi_type_Size7.type = FFI_TYPE_STRUCT;
+      ffi_type_Size7.size = sizeof(Size7);
+      ffi_type_Size7.alignment = alignof_slot(Size7);
+      ffi_type_Size7.elements = ffi_type_Size7_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size7);
+      {
+        FFI_CALL(cif,S7_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 49
+  {
+    Size8 r = S8_v();
+    fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size8_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size8;
+      ffi_type_Size8.type = FFI_TYPE_STRUCT;
+      ffi_type_Size8.size = sizeof(Size8);
+      ffi_type_Size8.alignment = alignof_slot(Size8);
+      ffi_type_Size8.elements = ffi_type_Size8_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size8);
+      {
+        FFI_CALL(cif,S8_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 50
+  {
+    Size12 r = S12_v();
+    fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size12_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size12;
+      ffi_type_Size12.type = FFI_TYPE_STRUCT;
+      ffi_type_Size12.size = sizeof(Size12);
+      ffi_type_Size12.alignment = alignof_slot(Size12);
+      ffi_type_Size12.elements = ffi_type_Size12_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size12);
+      {
+        FFI_CALL(cif,S12_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 51  
+  {
+    Size15 r = S15_v();
+    fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size15_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size15;
+      ffi_type_Size15.type = FFI_TYPE_STRUCT;
+      ffi_type_Size15.size = sizeof(Size15);
+      ffi_type_Size15.alignment = alignof_slot(Size15);
+      ffi_type_Size15.elements = ffi_type_Size15_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size15);
+      {
+        FFI_CALL(cif,S15_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
+    fflush(out);
+  }
+#endif
+#if (!defined(DGTEST)) || DGTEST == 52  
+  {
+    Size16 r = S16_v();
+    fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
+    fflush(out);
+    memset(&r,0,sizeof(r)); clear_traces();
+    {
+      ffi_type* ffi_type_Size16_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
+      ffi_type ffi_type_Size16;
+      ffi_type_Size16.type = FFI_TYPE_STRUCT;
+      ffi_type_Size16.size = sizeof(Size16);
+      ffi_type_Size16.alignment = alignof_slot(Size16);
+      ffi_type_Size16.elements = ffi_type_Size16_elements;
+      ffi_cif cif;
+      FFI_PREP_CIF_NOARGS(cif,ffi_type_Size16);
+      {
+        FFI_CALL(cif,S16_v,NULL,&r);
+      }
+    }
+    fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
+    fflush(out);
+  }
+#endif
+}
+void
+  structure_tests (void)
+{
+  Int Ir;
+  Char Cr;
+  Float Fr;
+  Double Dr;
+  J Jr;
+#ifndef SKIP_EXTRA_STRUCTS  
+  T Tr;
+  X Xr;
+#endif  
+
+#if (!defined(DGTEST)) || DGTEST == 53  
+  Ir = I_III(I1,I2,I3);
+  fprintf(out,"->{%d}\n",Ir.x);
+  fflush(out);
+  Ir.x = 0; clear_traces();
+  {
+    ffi_type* ffi_type_Int_elements[] = { &ffi_type_sint, NULL };
+    ffi_type ffi_type_Int;
+    ffi_type_Int.type = FFI_TYPE_STRUCT;
+    ffi_type_Int.size = sizeof(Int);
+    ffi_type_Int.alignment = alignof_slot(Int);
+    ffi_type_Int.elements = ffi_type_Int_elements;
+    ffi_type* argtypes[] = { &ffi_type_Int, &ffi_type_Int, &ffi_type_Int };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_Int);
+    {
+      /*const*/ void* args[] = { &I1, &I2, &I3 };
+      FFI_CALL(cif,I_III,args,&Ir);
+    }
+  }
+  fprintf(out,"->{%d}\n",Ir.x);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 54
+  Cr = C_CdC(C1,d2,C3);
+  fprintf(out,"->{'%c'}\n",Cr.x);
+  fflush(out);
+  Cr.x = '\0'; clear_traces();
+  {
+    ffi_type* ffi_type_Char_elements[] = { &ffi_type_char, NULL };
+    ffi_type ffi_type_Char;
+    ffi_type_Char.type = FFI_TYPE_STRUCT;
+    ffi_type_Char.size = sizeof(Char);
+    ffi_type_Char.alignment = alignof_slot(Char);
+    ffi_type_Char.elements = ffi_type_Char_elements;
+    ffi_type* argtypes[] = { &ffi_type_Char, &ffi_type_double, &ffi_type_Char };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_Char);
+    {
+      /*const*/ void* args[] = { &C1, &d2, &C3 };
+      FFI_CALL(cif,C_CdC,args,&Cr);
+    }
+  }
+  fprintf(out,"->{'%c'}\n",Cr.x);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 55
+  Fr = F_Ffd(F1,f2,d3);
+  fprintf(out,"->{%g}\n",Fr.x);
+  fflush(out);
+  Fr.x = 0.0; clear_traces();
+  {
+    ffi_type* ffi_type_Float_elements[] = { &ffi_type_float, NULL };
+    ffi_type ffi_type_Float;
+    ffi_type_Float.type = FFI_TYPE_STRUCT;
+    ffi_type_Float.size = sizeof(Float);
+    ffi_type_Float.alignment = alignof_slot(Float);
+    ffi_type_Float.elements = ffi_type_Float_elements;
+    ffi_type* argtypes[] = { &ffi_type_Float, &ffi_type_float, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_Float);
+    {
+      /*const*/ void* args[] = { &F1, &f2, &d3 };
+      FFI_CALL(cif,F_Ffd,args,&Fr);
+    }
+  }
+  fprintf(out,"->{%g}\n",Fr.x);
+  fflush(out);
+#endif  
+#if (!defined(DGTEST)) || DGTEST == 56  
+  Dr = D_fDd(f1,D2,d3);
+  fprintf(out,"->{%g}\n",Dr.x);
+  fflush(out);
+  Dr.x = 0.0; clear_traces();
+  {
+    ffi_type* ffi_type_Double_elements[] = { &ffi_type_double, NULL };
+    ffi_type ffi_type_Double;
+    ffi_type_Double.type = FFI_TYPE_STRUCT;
+    ffi_type_Double.size = sizeof(Double);
+    ffi_type_Double.alignment = alignof_slot(Double);
+    ffi_type_Double.elements = ffi_type_Double_elements;
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_Double, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_Double);
+    {
+      /*const*/ void* args[] = { &f1, &D2, &d3 };
+      FFI_CALL(cif,D_fDd,args,&Dr);
+    }
+  }
+  fprintf(out,"->{%g}\n",Dr.x);
+  fflush(out);
+#endif  
+#if (!defined(DGTEST)) || DGTEST == 57  
+  Dr = D_Dfd(D1,f2,d3);
+  fprintf(out,"->{%g}\n",Dr.x);
+  fflush(out);
+  Dr.x = 0.0; clear_traces();
+  {
+    ffi_type* ffi_type_Double_elements[] = { &ffi_type_double, NULL };
+    ffi_type ffi_type_Double;
+    ffi_type_Double.type = FFI_TYPE_STRUCT;
+    ffi_type_Double.size = sizeof(Double);
+    ffi_type_Double.alignment = alignof_slot(Double);
+    ffi_type_Double.elements = ffi_type_Double_elements;
+    ffi_type* argtypes[] = { &ffi_type_Double, &ffi_type_float, &ffi_type_double };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_Double);
+    {
+      /*const*/ void* args[] = { &D1, &f2, &d3 };
+      FFI_CALL(cif,D_Dfd,args,&Dr);
+    }
+  }
+  fprintf(out,"->{%g}\n",Dr.x);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 58  
+  Jr = J_JiJ(J1,i2,J2);
+  fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
+  fflush(out);
+  Jr.l1 = Jr.l2 = 0; clear_traces();
+  {
+    ffi_type* ffi_type_J_elements[] = { &ffi_type_slong, &ffi_type_slong, NULL };
+    ffi_type ffi_type_J;
+    ffi_type_J.type = FFI_TYPE_STRUCT;
+    ffi_type_J.size = sizeof(J);
+    ffi_type_J.alignment = alignof_slot(J);
+    ffi_type_J.elements = ffi_type_J_elements;
+    ffi_type* argtypes[] = { &ffi_type_J, &ffi_type_sint, &ffi_type_J };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_J);
+    {
+      /*const*/ void* args[] = { &J1, &i2, &J2 };
+      FFI_CALL(cif,J_JiJ,args,&Jr);
+    }
+  }
+  fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
+  fflush(out);
+#endif
+#ifndef SKIP_EXTRA_STRUCTS
+#if (!defined(DGTEST)) || DGTEST == 59
+  Tr = T_TcT(T1,' ',T2);
+  fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
+  fflush(out);
+  Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
+  {
+    ffi_type* ffi_type_T_elements[] = { ??, NULL };
+    ffi_type ffi_type_T;
+    ffi_type_T.type = FFI_TYPE_STRUCT;
+    ffi_type_T.size = sizeof(T);
+    ffi_type_T.alignment = alignof_slot(T);
+    ffi_type_T.elements = ffi_type_T_elements;
+    ffi_type* argtypes[] = { &ffi_type_T, &ffi_type_char, &ffi_type_T };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_T);
+    {
+      char space = ' ';
+      /*const*/ void* args[] = { &T1, &space, &T2 };
+      FFI_CALL(cif,T_TcT,args,&Tr);
+    }
+  }
+  fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 60
+  Xr = X_BcdB(B1,c2,d3,B2);
+  fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
+  fflush(out);
+  Xr.c[0]=Xr.c1='\0'; clear_traces();
+  {
+    ffi_type* ffi_type_X_elements[] = { ??, NULL };
+    ffi_type ffi_type_X;
+    ffi_type_X.type = FFI_TYPE_STRUCT;
+    ffi_type_X.size = sizeof(X);
+    ffi_type_X.alignment = alignof_slot(X);
+    ffi_type_X.elements = ffi_type_X_elements;
+    ffi_type* argtypes[] = { &ffi_type_X, &ffi_type_char, &ffi_type_double, &ffi_type_X };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_X);
+    {
+      /*const*/ void* args[] = { &B1, &c2, &d3, &B2 };
+      FFI_CALL(cif,X_BcdB,args,&Xr);
+    }
+  }
+  fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
+  fflush(out);
+#endif
+#endif
+
+  return;
+}
+
+void
+  gpargs_boundary_tests (void)
+{
+  ffi_type* ffi_type_K_elements[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, NULL };
+  ffi_type ffi_type_K;
+  ffi_type* ffi_type_L_elements[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, NULL };
+  ffi_type ffi_type_L;
+  long lr;
+  long long llr;
+  float fr;
+  double dr;
+
+  ffi_type_K.type = FFI_TYPE_STRUCT;
+  ffi_type_K.size = sizeof(K);
+  ffi_type_K.alignment = alignof_slot(K);
+  ffi_type_K.elements = ffi_type_K_elements;
+
+  ffi_type_L.type = FFI_TYPE_STRUCT;
+  ffi_type_L.size = sizeof(L);
+  ffi_type_L.alignment = alignof_slot(L);
+  ffi_type_L.elements = ffi_type_L_elements;
+
+#if (!defined(DGTEST)) || DGTEST == 61  
+  lr = l_l0K(K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &K1, &l9 };
+      FFI_CALL(cif,l_l0K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 62  
+  lr = l_l1K(l1,K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &l1, &K1, &l9 };
+      FFI_CALL(cif,l_l1K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 63  
+  lr = l_l2K(l1,l2,K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &K1, &l9 };
+      FFI_CALL(cif,l_l2K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 64  
+  lr = l_l3K(l1,l2,l3,K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &K1, &l9 };
+      FFI_CALL(cif,l_l3K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 65
+  lr = l_l4K(l1,l2,l3,l4,K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &K1, &l9 };
+      FFI_CALL(cif,l_l4K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 66
+  lr = l_l5K(l1,l2,l3,l4,l5,K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &K1, &l9 };
+      FFI_CALL(cif,l_l5K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 67  
+  lr = l_l6K(l1,l2,l3,l4,l5,l6,K1,l9);
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+  lr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &l6, &K1, &l9 };
+      FFI_CALL(cif,l_l6K,args,&lr);
+    }
+  }
+  fprintf(out,"->%ld\n",lr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 68  
+  fr = f_f17l3L(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+  fr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_L };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_float);
+    {
+      /*const*/ void* args[] = { &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9, &f10, &f11, &f12, &f13, &f14, &f15, &f16, &f17, &l6, &l7, &l8, &L1 };
+      FFI_CALL(cif,f_f17l3L,args,&fr);
+    }
+  }
+  fprintf(out,"->%g\n",fr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 69  
+  dr = d_d17l3L(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_L };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9, &d10, &d11, &d12, &d13, &d14, &d15, &d16, &d17, &l6, &l7, &l8, &L1 };
+      FFI_CALL(cif,d_d17l3L,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 70  
+  llr = ll_l2ll(l1,l2,ll1,l9);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &ll1, &l9 };
+      FFI_CALL(cif,ll_l2ll,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 71
+  llr = ll_l3ll(l1,l2,l3,ll1,l9);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &ll1, &l9 };
+      FFI_CALL(cif,ll_l3ll,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 72  
+  llr = ll_l4ll(l1,l2,l3,l4,ll1,l9);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &ll1, &l9 };
+      FFI_CALL(cif,ll_l4ll,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 73  
+  llr = ll_l5ll(l1,l2,l3,l4,l5,ll1,l9);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &ll1, &l9 };
+      FFI_CALL(cif,ll_l5ll,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 74  
+  llr = ll_l6ll(l1,l2,l3,l4,l5,l6,ll1,l9);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &l6, &ll1, &l9 };
+      FFI_CALL(cif,ll_l6ll,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 75  
+  llr = ll_l7ll(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+  llr = 0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &l6, &l7, &ll1, &l9 };
+      FFI_CALL(cif,ll_l7ll,args,&llr);
+    }
+  }
+  fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 76  
+  dr = d_l2d(l1,l2,d2,l9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &d2, &l9 };
+      FFI_CALL(cif,d_l2d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 77  
+  dr = d_l3d(l1,l2,l3,d2,l9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &d2, &l9 };
+      FFI_CALL(cif,d_l3d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 78  
+  dr = d_l4d(l1,l2,l3,l4,d2,l9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &d2, &l9 };
+      FFI_CALL(cif,d_l4d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 79  
+  dr = d_l5d(l1,l2,l3,l4,l5,d2,l9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &d2, &l9 };
+      FFI_CALL(cif,d_l5d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 80  
+  dr = d_l6d(l1,l2,l3,l4,l5,l6,d2,l9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &l6, &d2, &l9 };
+      FFI_CALL(cif,d_l6d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+#if (!defined(DGTEST)) || DGTEST == 81  
+  dr = d_l7d(l1,l2,l3,l4,l5,l6,l7,d2,l9);
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+  dr = 0.0; clear_traces();
+  {
+    ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
+    ffi_cif cif;
+    FFI_PREP_CIF(cif,argtypes,ffi_type_double);
+    {
+      /*const*/ void* args[] = { &l1, &l2, &l3, &l4, &l5, &l6, &l7, &d2, &l9 };
+      FFI_CALL(cif,d_l7d,args,&dr);
+    }
+  }
+  fprintf(out,"->%g\n",dr);
+  fflush(out);
+#endif
+  return;
+}
+
+int
+  main (void)
+{
+  ffi_type_char = (char)(-1) < 0 ? ffi_type_schar : ffi_type_uchar;
+  out = stdout;
+
+  void_tests();
+  int_tests();
+  float_tests();
+  double_tests();
+  pointer_tests();
+  mixed_number_tests();
+  small_structure_return_tests();
+  structure_tests();
+  gpargs_boundary_tests();
+
+  exit(0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.bhaible/testcases.c

@@ -0,0 +1,747 @@
+/*
+ * Copyright 1993 Bill Triggs <Bill.Triggs@inrialpes.fr>
+ * Copyright 1995-2017 Bruno Haible <bruno@clisp.org>
+ *
+ * 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
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* This file defines test functions of selected signatures, that exercise
+   dark corners of the various ABIs. */
+
+#include <stdio.h>
+
+FILE* out;
+
+#define uchar unsigned char
+#define ushort unsigned short
+#define uint unsigned int
+#define ulong unsigned long
+
+typedef struct { char x; } Char;
+typedef struct { short x; } Short;
+typedef struct { int x; } Int;
+typedef struct { long x; } Long;
+typedef struct { float x; } Float;
+typedef struct { double x; } Double;
+typedef struct { char c; float f; } A;
+typedef struct { double d; int i[3]; } B;
+typedef struct { long l1; long l2; } J;
+typedef struct { long l1; long l2; long l3; long l4; } K;
+typedef struct { long l1; long l2; long l3; long l4; long l5; long l6; } L;
+typedef struct { char x1; } Size1;
+typedef struct { char x1; char x2; } Size2;
+typedef struct { char x1; char x2; char x3; } Size3;
+typedef struct { char x1; char x2; char x3; char x4; } Size4;
+typedef struct {
+  char x1; char x2; char x3; char x4; char x5; char x6; char x7;
+} Size7;
+typedef struct {
+  char x1; char x2; char x3; char x4; char x5; char x6; char x7; char x8;
+} Size8;
+typedef struct {
+  char x1; char x2; char x3; char x4; char x5; char x6; char x7; char x8;
+  char x9; char x10; char x11; char x12;
+} Size12;
+typedef struct {
+  char x1; char x2; char x3; char x4; char x5; char x6; char x7; char x8;
+  char x9; char x10; char x11; char x12; char x13; char x14; char x15;
+} Size15;
+typedef struct {
+  char x1; char x2; char x3; char x4; char x5; char x6; char x7; char x8;
+  char x9; char x10; char x11; char x12; char x13; char x14; char x15; char x16;
+} Size16;
+typedef struct { char c[3]; } T;
+typedef struct { char c[33],c1; } X;
+
+/* 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;
+long l1=1, l2=2, l3=3, l4=4, l5=5, l6=6, l7=7, l8=8, l9=9;
+long long ll1 = 3875056143130689530LL;
+float f1=0.1f, f2=0.2f, f3=0.3f, f4=0.4f, f5=0.5f, f6=0.6f, f7=0.7f, f8=0.8f, f9=0.9f,
+      f10=1.1f, f11=1.2f, f12=1.3f, f13=1.4f, f14=1.5f, f15=1.6f, f16=1.7f, f17=1.8f,
+      f18=1.9f, f19=2.1f, f20=2.2f, f21=2.3f, f22=2.4f, f23=2.5f, f24=2.6f;
+double d1=0.1, d2=0.2, d3=0.3, d4=0.4, d5=0.5, d6=0.6, d7=0.7, d8=0.8, d9=0.9,
+       d10=1.1, d11=1.2, d12=1.3, d13=1.4, d14=1.5, d15=1.6, d16=1.7, d17=1.8;
+
+uchar uc1='a', uc2=127, uc3=128, uc4=255, uc5=(uchar)-1;
+ushort us1=1, us2=2, us3=3, us4=4, us5=5, us6=6, us7=7, us8=8, us9=9;
+uint ui1=1, ui2=2, ui3=3, ui4=4, ui5=5, ui6=6, ui7=7, ui8=8, ui9=9;
+ulong ul1=1, ul2=2, ul3=3, ul4=4, ul5=5, ul6=6, ul7=7, ul8=8, ul9=9;
+
+char *str1="hello",str2[]="goodbye",*str3="still here?";
+Char C1={'A'}, C2={'B'}, C3={'C'}, C4={'\377'}, C5={(char)(-1)};
+Short S1={1}, S2={2}, 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};
+Float F1={0.1f}, F2={0.2f}, F3={0.3f}, F4={0.4f}, F5={0.5f}, F6={0.6f}, F7={0.7f}, F8={0.8f}, F9={0.9f};
+Double D1={0.1}, D2={0.2}, D3={0.3}, D4={0.4}, D5={0.5}, D6={0.6}, D7={0.7}, D8={0.8}, D9={0.9};
+
+A A1={'a',0.1f},A2={'b',0.2f},A3={'\377',0.3f};
+B B1={0.1,{1,2,3}},B2={0.2,{5,4,3}};
+J J1={47,11},J2={73,55};
+K K1={19,69,12,28};
+L L1={561,1105,1729,2465,2821,6601}; /* A002997 */
+Size1 Size1_1={'a'};
+Size2 Size2_1={'a','b'};
+Size3 Size3_1={'a','b','c'};
+Size4 Size4_1={'a','b','c','d'};
+Size7 Size7_1={'a','b','c','d','e','f','g'};
+Size8 Size8_1={'a','b','c','d','e','f','g','h'};
+Size12 Size12_1={'a','b','c','d','e','f','g','h','i','j','k','l'};
+Size15 Size15_1={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o'};
+Size16 Size16_1={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'};
+T T1={{'t','h','e'}},T2={{'f','o','x'}};
+X X1={"abcdefghijklmnopqrstuvwxyzABCDEF",'G'}, X2={"123",'9'}, X3={"return-return-return",'R'};
+
+#if defined(__GNUC__)
+#define __STDCALL__ __attribute__((stdcall))
+#define __THISCALL__ __attribute__((thiscall))
+#define __FASTCALL__ __attribute__((fastcall))
+#define __MSABI__ __attribute__((ms_abi))
+#else
+#define __STDCALL__ __stdcall
+#define __THISCALL__ __thiscall
+#define __FASTCALL__ __fastcall
+#endif
+
+#ifndef ABI_ATTR
+#define ABI_ATTR
+#endif
+
+/* void tests */
+void ABI_ATTR v_v (void)
+{
+  fprintf(out,"void f(void):\n");
+  fflush(out);
+}
+
+/* int tests */
+int ABI_ATTR i_v (void)
+{
+  int r=99;
+  fprintf(out,"int f(void):");
+  fflush(out);
+  return r;
+}
+int ABI_ATTR i_i (int a)
+{
+  int r=a+1;
+  fprintf(out,"int f(int):(%d)",a);
+  fflush(out);
+  return r;
+}
+int ABI_ATTR i_i2 (int a, int b)
+{
+  int r=a+b;
+  fprintf(out,"int f(2*int):(%d,%d)",a,b);
+  fflush(out);
+  return r;
+}
+int ABI_ATTR i_i4 (int a, int b, int c, int d)
+{
+  int r=a+b+c+d;
+  fprintf(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+int ABI_ATTR i_i8 (int a, int b, int c, int d, int e, int f, int g, int h)
+{
+  int r=a+b+c+d+e+f+g+h;
+  fprintf(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
+  fflush(out);
+  return r;
+}
+int ABI_ATTR i_i16 (int a, int b, int c, int d, int e, int f, int g, int h,
+           int i, int j, int k, int l, int m, int n, int o, int p)
+{
+  int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
+  fprintf(out,"int f(16*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+          a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
+  fflush(out);
+  return r;
+}
+
+/* float tests */
+float ABI_ATTR f_f (float a)
+{
+  float r=a+1.0f;
+  fprintf(out,"float f(float):(%g)",a);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f2 (float a, float b)
+{
+  float r=a+b;
+  fprintf(out,"float f(2*float):(%g,%g)",a,b);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f4 (float a, float b, float c, float d)
+{
+  float r=a+b+c+d;
+  fprintf(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f8 (float a, float b, float c, float d, float e, float f,
+            float g, float h)
+{
+  float r=a+b+c+d+e+f+g+h;
+  fprintf(out,"float f(8*float):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f16 (float a, float b, float c, float d, float e, float f, float g, float h,
+             float i, float j, float k, float l, float m, float n, float o, float p)
+{
+  float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
+  fprintf(out,"float f(16*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f24 (float a, float b, float c, float d, float e, float f, float g, float h,
+             float i, float j, float k, float l, float m, float n, float o, float p,
+             float q, float s, float t, float u, float v, float w, float x, float y)
+{
+  float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+v+w+x+y;
+  fprintf(out,"float f(24*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,v,w,x,y);
+  fflush(out);
+  return r;
+}
+
+/* double tests */
+double ABI_ATTR d_d (double a)
+{
+  double r=a+1.0;
+  fprintf(out,"double f(double):(%g)",a);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d2 (double a, double b)
+{
+  double r=a+b;
+  fprintf(out,"double f(2*double):(%g,%g)",a,b);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d4 (double a, double b, double c, double d)
+{
+  double r=a+b+c+d;
+  fprintf(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d8 (double a, double b, double c, double d, double e, double f,
+             double g, double h)
+{
+  double r=a+b+c+d+e+f+g+h;
+  fprintf(out,"double f(8*double):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d16 (double a, double b, double c, double d, double e, double f,
+              double g, double h, double i, double j, double k, double l,
+              double m, double n, double o, double p)
+{
+  double r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
+  fprintf(out,"double f(16*double):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
+  fflush(out);
+  return r;
+}
+
+/* pointer tests */
+void* ABI_ATTR vp_vpdpcpsp (void* a, double* b, char* c, Int* d)
+{
+  void* ret = (char*)b + 1;
+  fprintf(out,"void* f(void*,double*,char*,Int*):(0x%p,0x%p,0x%p,0x%p)",a,b,c,d);
+  fflush(out);
+  return ret;
+}
+
+/* mixed number tests */
+uchar ABI_ATTR uc_ucsil (uchar a, ushort b, uint c, ulong d)
+{
+  uchar r = (uchar)-1;
+  fprintf(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%lu)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_iidd (int a, int b, double c, double d)
+{
+  double r = a+b+c+d;
+  fprintf(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_iiidi (int a, int b, int c, double d, int e)
+{
+  double r = a+b+c+d+e;
+  fprintf(out,"double f(int,int,int,double,int):(%d,%d,%d,%g,%d)",a,b,c,d,e);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_idid (int a, double b, int c, double d)
+{
+  double r = a+b+c+d;
+  fprintf(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_fdi (float a, double b, int c)
+{
+  double r = a+b+c;
+  fprintf(out,"double f(float,double,int):(%g,%g,%d)",a,b,c);
+  fflush(out);
+  return r;
+}
+ushort ABI_ATTR us_cdcd (char a, double b, char c, double d)
+{
+  ushort r = (ushort)(a + b + c + d);
+  fprintf(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
+  fflush(out);
+  return r;
+}
+
+long long ABI_ATTR ll_iiilli (int a, int b, int c, long long d, int e)
+{
+  long long r = (long long)(int)a+(long long)(int)b+(long long)(int)c+d+(long long)(int)e;
+  fprintf(out,"long long f(int,int,int,long long,int):(%d,%d,%d,0x%lx%08lx,%d)",a,b,c,(long)(d>>32),(long)(d&0xffffffff),e);
+  fflush(out);
+  return r;
+}
+long long ABI_ATTR ll_flli (float a, long long b, int c)
+{
+  long long r = (long long)(int)a + b + (long long)c;
+  fprintf(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
+  fflush(out);
+  return r;
+}
+
+float ABI_ATTR f_fi (float a, int z)
+{
+  float r = a+z;
+  fprintf(out,"float f(float,int):(%g,%d)",a,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f2i (float a, float b, int z)
+{
+  float r = a+b+z;
+  fprintf(out,"float f(2*float,int):(%g,%g,%d)",a,b,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f3i (float a, float b, float c, int z)
+{
+  float r = a+b+c+z;
+  fprintf(out,"float f(3*float,int):(%g,%g,%g,%d)",a,b,c,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f4i (float a, float b, float c, float d, int z)
+{
+  float r = a+b+c+d+z;
+  fprintf(out,"float f(4*float,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f7i (float a, float b, float c, float d, float e, float f, float g,
+             int z)
+{
+  float r = a+b+c+d+e+f+g+z;
+  fprintf(out,"float f(7*float,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f8i (float a, float b, float c, float d, float e, float f, float g,
+             float h, int z)
+{
+  float r = a+b+c+d+e+f+g+h+z;
+  fprintf(out,"float f(8*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f12i (float a, float b, float c, float d, float e, float f, float g,
+              float h, float i, float j, float k, float l, int z)
+{
+  float r = a+b+c+d+e+f+g+h+i+j+k+l+z;
+  fprintf(out,"float f(12*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
+  fflush(out);
+  return r;
+}
+float ABI_ATTR f_f13i (float a, float b, float c, float d, float e, float f, float g,
+              float h, float i, float j, float k, float l, float m, int z)
+{
+  float r = a+b+c+d+e+f+g+h+i+j+k+l+m+z;
+  fprintf(out,"float f(13*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
+  fflush(out);
+  return r;
+}
+
+double ABI_ATTR d_di (double a, int z)
+{
+  double r = a+z;
+  fprintf(out,"double f(double,int):(%g,%d)",a,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d2i (double a, double b, int z)
+{
+  double r = a+b+z;
+  fprintf(out,"double f(2*double,int):(%g,%g,%d)",a,b,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d3i (double a, double b, double c, int z)
+{
+  double r = a+b+c+z;
+  fprintf(out,"double f(3*double,int):(%g,%g,%g,%d)",a,b,c,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d4i (double a, double b, double c, double d, int z)
+{
+  double r = a+b+c+d+z;
+  fprintf(out,"double f(4*double,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d7i (double a, double b, double c, double d, double e, double f,
+              double g, int z)
+{
+  double r = a+b+c+d+e+f+g+z;
+  fprintf(out,"double f(7*double,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d8i (double a, double b, double c, double d, double e, double f,
+              double g, double h, int z)
+{
+  double r = a+b+c+d+e+f+g+h+z;
+  fprintf(out,"double f(8*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d12i (double a, double b, double c, double d, double e, double f,
+               double g, double h, double i, double j, double k, double l,
+               int z)
+{
+  double r = a+b+c+d+e+f+g+h+i+j+k+l+z;
+  fprintf(out,"double f(12*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d13i (double a, double b, double c, double d, double e, double f,
+               double g, double h, double i, double j, double k, double l,
+               double m, int z)
+{
+  double r = a+b+c+d+e+f+g+h+i+j+k+l+m+z;
+  fprintf(out,"double f(13*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
+  fflush(out);
+  return r;
+}
+
+/* small structure return tests */
+Size1 ABI_ATTR S1_v (void)
+{
+  fprintf(out,"Size1 f(void):");
+  fflush(out);
+  return Size1_1;
+}
+Size2 ABI_ATTR S2_v (void)
+{
+  fprintf(out,"Size2 f(void):");
+  fflush(out);
+  return Size2_1;
+}
+Size3 ABI_ATTR S3_v (void)
+{
+  fprintf(out,"Size3 f(void):");
+  fflush(out);
+  return Size3_1;
+}
+Size4 ABI_ATTR S4_v (void)
+{
+  fprintf(out,"Size4 f(void):");
+  fflush(out);
+  return Size4_1;
+}
+Size7 ABI_ATTR S7_v (void)
+{
+  fprintf(out,"Size7 f(void):");
+  fflush(out);
+  return Size7_1;
+}
+Size8 ABI_ATTR S8_v (void)
+{
+  fprintf(out,"Size8 f(void):");
+  fflush(out);
+  return Size8_1;
+}
+Size12 ABI_ATTR S12_v (void)
+{
+  fprintf(out,"Size12 f(void):");
+  fflush(out);
+  return Size12_1;
+}
+Size15 ABI_ATTR S15_v (void)
+{
+  fprintf(out,"Size15 f(void):");
+  fflush(out);
+  return Size15_1;
+}
+Size16 ABI_ATTR S16_v (void)
+{
+  fprintf(out,"Size16 f(void):");
+  fflush(out);
+  return Size16_1;
+}
+
+/* structure tests */
+Int ABI_ATTR I_III (Int a, Int b, Int c)
+{
+  Int r;
+  r.x = a.x + b.x + c.x;
+  fprintf(out,"Int f(Int,Int,Int):({%d},{%d},{%d})",a.x,b.x,c.x);
+  fflush(out);
+  return r;
+}
+Char ABI_ATTR C_CdC (Char a, double b, Char c)
+{
+  Char r;
+  r.x = (a.x + c.x)/2;
+  fprintf(out,"Char f(Char,double,Char):({'%c'},%g,{'%c'})",a.x,b,c.x);
+  fflush(out);
+  return r;
+}
+Float ABI_ATTR F_Ffd (Float a, float b, double c)
+{
+  Float r;
+  r.x = (float) (a.x + b + c);
+  fprintf(out,"Float f(Float,float,double):({%g},%g,%g)",a.x,b,c);
+  fflush(out);
+  return r;
+}
+Double ABI_ATTR D_fDd (float a, Double b, double c)
+{
+  Double r;
+  r.x = a + b.x + c;
+  fprintf(out,"Double f(float,Double,double):(%g,{%g},%g)",a,b.x,c);
+  fflush(out);
+  return r;
+}
+Double ABI_ATTR D_Dfd (Double a, float b, double c)
+{
+  Double r;
+  r.x = a.x + b + c;
+  fprintf(out,"Double f(Double,float,double):({%g},%g,%g)",a.x,b,c);
+  fflush(out);
+  return r;
+}
+J ABI_ATTR J_JiJ (J a, int b, J c)
+{
+  J r;
+  r.l1 = a.l1+c.l1; r.l2 = a.l2+b+c.l2;
+  fprintf(out,"J f(J,int,J):({%ld,%ld},%d,{%ld,%ld})",a.l1,a.l2,b,c.l1,c.l2);
+  fflush(out);
+  return r;
+}
+T ABI_ATTR T_TcT (T a, char b, T c)
+{
+  T r;
+  r.c[0]='b'; r.c[1]=c.c[1]; r.c[2]=c.c[2];
+  fprintf(out,"T f(T,char,T):({\"%c%c%c\"},'%c',{\"%c%c%c\"})",a.c[0],a.c[1],a.c[2],b,c.c[0],c.c[1],c.c[2]);
+  fflush(out);
+  return r;
+}
+X ABI_ATTR X_BcdB (B a, char b, double c, B d)
+{
+  static X xr={"return val",'R'};
+  X r;
+  r = xr;
+  r.c1 = b;
+  fprintf(out,"X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})",
+          a.d,a.i[0],a.i[1],a.i[2],b,c,d.d,d.i[0],d.i[1],d.i[2]);
+  fflush(out);
+  return r;
+}
+
+/* Test for cases where some argument (especially structure, 'long long', or
+   'double') may be passed partially in general-purpose argument registers
+   and partially on the stack. Different ABIs pass between 4 and 8 arguments
+   (or none) in general-purpose argument registers. */
+
+long ABI_ATTR l_l0K (K b, long c)
+{
+  long r = b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(K,long):(%ld,%ld,%ld,%ld,%ld)",b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+long ABI_ATTR l_l1K (long a1, K b, long c)
+{
+  long r = a1 + b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+long ABI_ATTR l_l2K (long a1, long a2, K b, long c)
+{
+  long r = a1 + a2 + b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(2*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+long ABI_ATTR l_l3K (long a1, long a2, long a3, K b, long c)
+{
+  long r = a1 + a2 + a3 + b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(3*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+long ABI_ATTR l_l4K (long a1, long a2, long a3, long a4, K b, long c)
+{
+  long r = a1 + a2 + a3 + a4 + b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(4*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+long ABI_ATTR l_l5K (long a1, long a2, long a3, long a4, long a5, K b, long c)
+{
+  long r = a1 + a2 + a3 + a4 + a5 + b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(5*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+long ABI_ATTR l_l6K (long a1, long a2, long a3, long a4, long a5, long a6, K b, long c)
+{
+  long r = a1 + a2 + a3 + a4 + a5 + a6 + b.l1 + b.l2 + b.l3 + b.l4 + c;
+  fprintf(out,"long f(6*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,b.l1,b.l2,b.l3,b.l4,c);
+  fflush(out);
+  return r;
+}
+/* These tests is crafted on the knowledge that for all known ABIs:
+   * 17 > number of floating-point argument registers,
+   * 3 < number of general-purpose argument registers < 3 + 6. */
+float ABI_ATTR f_f17l3L (float a, float b, float c, float d, float e, float f, float g,
+                float h, float i, float j, float k, float l, float m, float n,
+                float o, float p, float q,
+                long s, long t, long u, L z)
+{
+  float r = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+z.l1+z.l2+z.l3+z.l4+z.l5+z.l6;
+  fprintf(out,"float f(17*float,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_d17l3L (double a, double b, double c, double d, double e, double f,
+                 double g, double h, double i, double j, double k, double l,
+                 double m, double n, double o, double p, double q,
+                 long s, long t, long u, L z)
+{
+  double r = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+z.l1+z.l2+z.l3+z.l4+z.l5+z.l6;
+  fprintf(out,"double f(17*double,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
+  fflush(out);
+  return r;
+}
+
+long long ABI_ATTR ll_l2ll (long a1, long a2, long long b, long c)
+{
+  long long r = (long long) (a1 + a2) + b + c;
+  fprintf(out,"long long f(2*long,long long,long):(%ld,%ld,0x%lx%08lx,%ld)",a1,a2,(long)(b>>32),(long)(b&0xffffffff),c);
+  fflush(out);
+  return r;
+}
+long long ABI_ATTR ll_l3ll (long a1, long a2, long a3, long long b, long c)
+{
+  long long r = (long long) (a1 + a2 + a3) + b + c;
+  fprintf(out,"long long f(3*long,long long,long):(%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,(long)(b>>32),(long)(b&0xffffffff),c);
+  fflush(out);
+  return r;
+}
+long long ABI_ATTR ll_l4ll (long a1, long a2, long a3, long a4, long long b, long c)
+{
+  long long r = (long long) (a1 + a2 + a3 + a4) + b + c;
+  fprintf(out,"long long f(4*long,long long,long):(%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,(long)(b>>32),(long)(b&0xffffffff),c);
+  fflush(out);
+  return r;
+}
+long long ABI_ATTR ll_l5ll (long a1, long a2, long a3, long a4, long a5, long long b, long c)
+{
+  long long r = (long long) (a1 + a2 + a3 + a4 + a5) + b + c;
+  fprintf(out,"long long f(5*long,long long,long):(%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,(long)(b>>32),(long)(b&0xffffffff),c);
+  fflush(out);
+  return r;
+}
+long long ABI_ATTR ll_l6ll (long a1, long a2, long a3, long a4, long a5, long a6, long long b, long c)
+{
+  long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
+  fprintf(out,"long long f(6*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,(long)(b>>32),(long)(b&0xffffffff),c);
+  fflush(out);
+  return r;
+}
+long long ABI_ATTR ll_l7ll (long a1, long a2, long a3, long a4, long a5, long a6, long a7, long long b, long c)
+{
+  long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
+  fprintf(out,"long long f(7*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,a7,(long)(b>>32),(long)(b&0xffffffff),c);
+  fflush(out);
+  return r;
+}
+
+double ABI_ATTR d_l2d (long a1, long a2, double b, long c)
+{
+  double r = (double) (a1 + a2) + b + c;
+  fprintf(out,"double f(2*long,double,long):(%ld,%ld,%g,%ld)",a1,a2,b,c);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_l3d (long a1, long a2, long a3, double b, long c)
+{
+  double r = (double) (a1 + a2 + a3) + b + c;
+  fprintf(out,"double f(3*long,double,long):(%ld,%ld,%ld,%g,%ld)",a1,a2,a3,b,c);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_l4d (long a1, long a2, long a3, long a4, double b, long c)
+{
+  double r = (double) (a1 + a2 + a3 + a4) + b + c;
+  fprintf(out,"double f(4*long,double,long):(%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,b,c);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_l5d (long a1, long a2, long a3, long a4, long a5, double b, long c)
+{
+  double r = (double) (a1 + a2 + a3 + a4 + a5) + b + c;
+  fprintf(out,"double f(5*long,double,long):(%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,b,c);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_l6d (long a1, long a2, long a3, long a4, long a5, long a6, double b, long c)
+{
+  double r = (double) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
+  fprintf(out,"double f(6*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,b,c);
+  fflush(out);
+  return r;
+}
+double ABI_ATTR d_l7d (long a1, long a2, long a3, long a4, long a5, long a6, long a7, double b, long c)
+{
+  double r = (double) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
+  fprintf(out,"double f(7*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,a7,b,c);
+  fflush(out);
+  return r;
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/align_mixed.c

@@ -0,0 +1,46 @@
+/* Area:	ffi_call
+   Purpose:	Check for proper argument alignment.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<twalljava@java.net> (from many_win32.c) */
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+
+static float ABI_ATTR align_arguments(int i1,
+                                      double f2,
+                                      int i3,
+                                      double f4)
+{
+  return i1+f2+i3+f4;
+}
+
+int main(void)
+{
+  ffi_cif cif;
+  ffi_type *args[4] = {
+    &ffi_type_sint,
+    &ffi_type_double,
+    &ffi_type_sint,
+    &ffi_type_double
+  };
+  double fa[2] = {1,2};
+  int ia[2] = {1,2};
+  void *values[4] = {&ia[0], &fa[0], &ia[1], &fa[1]};
+  float f, ff;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 4,
+		     &ffi_type_float, args) == FFI_OK);
+
+  ff = align_arguments(ia[0], fa[0], ia[1], fa[1]);
+
+  ffi_call(&cif, FFI_FN(align_arguments), &f, values);
+
+  if (f == ff)
+    printf("align arguments tests ok!\n");
+  else
+    CHECK(0);
+  exit(0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/align_stdcall.c

@@ -0,0 +1,46 @@
+/* Area:	ffi_call
+   Purpose:	Check for proper argument alignment.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<twalljava@java.net> (from many_win32.c) */
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+
+static float ABI_ATTR align_arguments(int i1,
+                                      double f2,
+                                      int i3,
+                                      double f4)
+{
+  return i1+f2+i3+f4;
+}
+
+int main(void)
+{
+  ffi_cif cif;
+  ffi_type *args[4] = {
+    &ffi_type_sint,
+    &ffi_type_double,
+    &ffi_type_sint,
+    &ffi_type_double
+  };
+  double fa[2] = {1,2};
+  int ia[2] = {1,2};
+  void *values[4] = {&ia[0], &fa[0], &ia[1], &fa[1]};
+  float f, ff;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 4,
+		     &ffi_type_float, args) == FFI_OK);
+
+  ff = align_arguments(ia[0], fa[0], ia[1], fa[1]);;
+
+  ffi_call(&cif, FFI_FN(align_arguments), &f, values);
+
+  if (f == ff)
+    printf("align arguments tests ok!\n");
+  else
+    CHECK(0);
+  exit(0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/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);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/call.exp

@@ -0,0 +1,54 @@
+# Copyright (C) 2003, 2006, 2009, 2010, 2014 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
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+dg-init
+libffi-init
+
+global srcdir subdir
+
+if { [string match $compiler_vendor "microsoft"] } {
+    # -wd4005  macro redefinition
+    # -wd4244  implicit conversion to type of smaller size
+    # -wd4305  truncation to smaller type
+    # -wd4477  printf %lu of uintptr_t
+    # -wd4312  implicit conversion to type of greater size
+    # -wd4311  pointer truncation to unsigned long
+    # -EHsc    C++ Exception Handling (no SEH exceptions)
+    set additional_options "-wd4005 -wd4244 -wd4305 -wd4477 -wd4312 -wd4311 -EHsc";
+} else {
+    set additional_options "";
+}
+
+set tlist [lsort [glob -nocomplain -- $srcdir/$subdir/*.c]]
+
+run-many-tests $tlist $additional_options
+
+set tlist [lsort [glob -nocomplain -- $srcdir/$subdir/*.cc]]
+
+# No C++ for or1k
+if { [istarget "or1k-*-*"] } {
+    foreach test $tlist {
+        unsupported "$test"
+    }
+} else {
+    run-many-tests $tlist $additional_options
+}
+
+dg-finish
+
+# Local Variables:
+# tcl-indent-level:4
+# End:

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/err_bad_typedef.c

@@ -0,0 +1,26 @@
+/* Area:		ffi_prep_cif
+   Purpose:		Test error return for bad typedefs.
+   Limitations:	none.
+   PR:			none.
+   Originator:	Blake Chaffin 6/6/2007	 */
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+
+int main (void)
+{
+	ffi_cif cif;
+	ffi_type* arg_types[1];
+
+	ffi_type	badType	= ffi_type_void;
+
+	arg_types[0] = NULL;
+
+	badType.size = 0;
+
+	CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 0, &badType,
+		arg_types) == FFI_BAD_TYPEDEF);
+
+	exit(0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/ffitest.h

@@ -0,0 +1,163 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <ffi.h>
+#include "fficonfig.h"
+
+#include <float.h>
+#include <math.h>
+
+#if defined HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#if defined HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+
+#define MAX_ARGS 256
+
+#define CHECK(x) \
+   do { \
+      if(!(x)){ \
+         printf("Check failed:\n%s\n", #x); \
+         abort(); \
+      } \
+   } while(0)
+
+#define CHECK_FLOAT_EQ(x, y) \
+   do { \
+      if(fabs((x) - (y)) > FLT_EPSILON){ \
+         printf("Check failed CHECK_FLOAT_EQ(%s, %s)\n", #x, #y); \
+         abort(); \
+      } \
+   } while(0)
+
+#define CHECK_DOUBLE_EQ(x, y) \
+   do { \
+      if(fabs((x) - (y)) > DBL_EPSILON){ \
+         printf("Check failed CHECK_FLOAT_EQ(%s, %s)\n", #x, #y); \
+         abort(); \
+      } \
+   } while(0)
+
+/* Define macros so that compilers other than gcc can run the tests.  */
+#undef __UNUSED__
+#if defined(__GNUC__)
+#define __UNUSED__ __attribute__((__unused__))
+#define __STDCALL__ __attribute__((stdcall))
+#define __THISCALL__ __attribute__((thiscall))
+#define __FASTCALL__ __attribute__((fastcall))
+#define __MSABI__ __attribute__((ms_abi))
+#else
+#define __UNUSED__
+#define __STDCALL__ __stdcall
+#define __THISCALL__ __thiscall
+#define __FASTCALL__ __fastcall
+#endif
+
+#ifndef ABI_NUM
+#define ABI_NUM FFI_DEFAULT_ABI
+#define ABI_ATTR
+#endif
+
+/* Prefer MAP_ANON(YMOUS) to /dev/zero, since we don't need to keep a
+   file open.  */
+#ifdef HAVE_MMAP_ANON
+# undef HAVE_MMAP_DEV_ZERO
+
+# include <sys/mman.h>
+# ifndef MAP_FAILED
+#  define MAP_FAILED -1
+# endif
+# if !defined (MAP_ANONYMOUS) && defined (MAP_ANON)
+#  define MAP_ANONYMOUS MAP_ANON
+# endif
+# define USING_MMAP
+
+#endif
+
+#ifdef HAVE_MMAP_DEV_ZERO
+
+# include <sys/mman.h>
+# ifndef MAP_FAILED
+#  define MAP_FAILED -1
+# endif
+# define USING_MMAP
+
+#endif
+
+/* msvc kludge.  */
+#if defined(_MSC_VER)
+#define PRIdLL "I64d"
+#define PRIuLL "I64u"
+#else
+#define PRIdLL "lld"
+#define PRIuLL "llu"
+#endif
+
+/* Tru64 UNIX kludge.  */
+#if defined(__alpha__) && defined(__osf__)
+/* Tru64 UNIX V4.0 doesn't support %lld/%lld, but long is 64-bit.  */
+#undef PRIdLL
+#define PRIdLL "ld"
+#undef PRIuLL
+#define PRIuLL "lu"
+#define PRId8 "hd"
+#define PRIu8 "hu"
+#define PRId64 "ld"
+#define PRIu64 "lu"
+#define PRIuPTR "lu"
+#endif
+
+/* PA HP-UX kludge.  */
+#if defined(__hppa__) && defined(__hpux__) && !defined(PRIuPTR)
+#define PRIuPTR "lu"
+#endif
+
+/* IRIX kludge.  */
+#if defined(__sgi)
+/* IRIX 6.5 <inttypes.h> provides all definitions, but only for C99
+   compilations.  */
+#define PRId8 "hhd"
+#define PRIu8 "hhu"
+#if (_MIPS_SZLONG == 32)
+#define PRId64 "lld"
+#define PRIu64 "llu"
+#endif
+/* This doesn't match <inttypes.h>, which always has "lld" here, but the
+   arguments are uint64_t, int64_t, which are unsigned long, long for
+   64-bit in <sgidefs.h>.  */
+#if (_MIPS_SZLONG == 64)
+#define PRId64 "ld"
+#define PRIu64 "lu"
+#endif
+/* This doesn't match <inttypes.h>, which has "u" here, but the arguments
+   are uintptr_t, which is always unsigned long.  */
+#define PRIuPTR "lu"
+#endif
+
+/* Solaris < 10 kludge.  */
+#if defined(__sun__) && defined(__svr4__) && !defined(PRIuPTR)
+#if defined(__arch64__) || defined (__x86_64__)
+#define PRIuPTR "lu"
+#else
+#define PRIuPTR "u"
+#endif
+#endif
+
+/* MSVC kludge.  */
+#if defined _MSC_VER
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS)
+#define PRIuPTR "lu"
+#define PRIu8 "u"
+#define PRId8 "d"
+#define PRIu64 "I64u"
+#define PRId64 "I64d"
+#endif
+#endif
+
+#ifndef PRIuPTR
+#define PRIuPTR "u"
+#endif

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/float.c

@@ -0,0 +1,59 @@
+/* Area:	ffi_call
+   Purpose:	Check return value float.
+   Limitations:	none.
+   PR:		none.
+   Originator:	From the original ffitest.c  */
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+
+static int floating(int a, float b, double c, long double d)
+{
+  int i;
+
+  i = (int) ((float)a/b + ((float)c/(float)d));
+
+  return i;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  ffi_arg rint;
+
+  float f;
+  signed int si1;
+  double d;
+  long double ld;
+
+  args[0] = &ffi_type_sint;
+  values[0] = &si1;
+  args[1] = &ffi_type_float;
+  values[1] = &f;
+  args[2] = &ffi_type_double;
+  values[2] = &d;
+  args[3] = &ffi_type_longdouble;
+  values[3] = &ld;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 4,
+		     &ffi_type_sint, args) == FFI_OK);
+
+  si1 = 6;
+  f = 3.14159;
+  d = (double)1.0/(double)3.0;
+  ld = 2.71828182846L;
+
+  floating (si1, f, d, ld);
+
+  ffi_call(&cif, FFI_FN(floating), &rint, values);
+
+  printf ("%d vs %d\n", (int)rint, floating (si1, f, d, ld));
+
+  CHECK((int)rint == floating(si1, f, d, ld));
+
+  exit (0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/float1.c

@@ -0,0 +1,60 @@
+/* Area:	ffi_call
+   Purpose:	Check return value double.
+   Limitations:	none.
+   PR:		none.
+   Originator:	From the original ffitest.c  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+#include "float.h"
+
+#include <math.h>
+
+typedef union
+{
+  double d;
+  unsigned char c[sizeof (double)];
+} value_type;
+
+#define CANARY 0xba
+
+static double dblit(float f)
+{
+  return f/3.0;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  float f;
+  value_type result[2];
+  unsigned int i;
+
+  args[0] = &ffi_type_float;
+  values[0] = &f;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
+		     &ffi_type_double, args) == FFI_OK);
+
+  f = 3.14159;
+
+  /* Put a canary in the return array.  This is a regression test for
+     a buffer overrun.  */
+  memset(result[1].c, CANARY, sizeof (double));
+
+  ffi_call(&cif, FFI_FN(dblit), &result[0].d, values);
+
+  /* These are not always the same!! Check for a reasonable delta */
+
+  CHECK(fabs(result[0].d - dblit(f)) < DBL_EPSILON);
+
+  /* Check the canary.  */
+  for (i = 0; i < sizeof (double); ++i)
+    CHECK(result[1].c[i] == CANARY);
+
+  exit(0);
+
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/float2.c

@@ -0,0 +1,61 @@
+/* Area:	ffi_call
+   Purpose:	Check return value long double.
+   Limitations:	none.
+   PR:		none.
+   Originator:	From the original ffitest.c  */
+/* { dg-do run } */
+
+#include "ffitest.h"
+#include "float.h"
+
+#include <math.h>
+
+static long double ldblit(float f)
+{
+  return (long double) (((long double) f)/ (long double) 3.0);
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  float f;
+  long double ld;
+  long double original;
+
+  args[0] = &ffi_type_float;
+  values[0] = &f;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
+		     &ffi_type_longdouble, args) == FFI_OK);
+
+  f = 3.14159;
+
+#if defined(__sun) && defined(__GNUC__)
+  /* long double support under SunOS/gcc is pretty much non-existent.
+     You'll get the odd bus error in library routines like printf() */
+#else
+  printf ("%Lf\n", ldblit(f));
+#endif
+
+  ld = 666;
+  ffi_call(&cif, FFI_FN(ldblit), &ld, values);
+
+#if defined(__sun) && defined(__GNUC__)
+  /* long double support under SunOS/gcc is pretty much non-existent.
+     You'll get the odd bus error in library routines like printf() */
+#else
+  printf ("%Lf, %Lf, %Lf, %Lf\n", ld, ldblit(f), ld - ldblit(f), LDBL_EPSILON);
+#endif
+
+  /* These are not always the same!! Check for a reasonable delta */
+  original = ldblit(f);
+  if (((ld > original) ? (ld - original) : (original - ld)) < LDBL_EPSILON)
+    puts("long double return value tests ok!");
+  else
+    CHECK(0);
+
+  exit(0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/float3.c

@@ -0,0 +1,74 @@
+/* Area:	ffi_call
+   Purpose:	Check float arguments with different orders.
+   Limitations:	none.
+   PR:		none.
+   Originator:	From the original ffitest.c  */
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+#include "float.h"
+
+#include <math.h>
+
+static double floating_1(float a, double b, long double c)
+{
+  return (double) a + b + (double) c;
+}
+
+static double floating_2(long double a, double b, float c)
+{
+  return (double) a + b + (double) c;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  double rd;
+
+  float f;
+  double d;
+  long double ld;
+
+  args[0] = &ffi_type_float;
+  values[0] = &f;
+  args[1] = &ffi_type_double;
+  values[1] = &d;
+  args[2] = &ffi_type_longdouble;
+  values[2] = &ld;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 3,
+		     &ffi_type_double, args) == FFI_OK);
+
+  f = 3.14159;
+  d = (double)1.0/(double)3.0;
+  ld = 2.71828182846L;
+
+  floating_1 (f, d, ld);
+
+  ffi_call(&cif, FFI_FN(floating_1), &rd, values);
+
+  CHECK(fabs(rd - floating_1(f, d, ld)) < DBL_EPSILON);
+
+  args[0] = &ffi_type_longdouble;
+  values[0] = &ld;
+  args[1] = &ffi_type_double;
+  values[1] = &d;
+  args[2] = &ffi_type_float;
+  values[2] = &f;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 3,
+		     &ffi_type_double, args) == FFI_OK);
+
+  floating_2 (ld, d, f);
+
+  ffi_call(&cif, FFI_FN(floating_2), &rd, values);
+
+  CHECK(fabs(rd - floating_2(ld, d, f)) < DBL_EPSILON);
+
+  exit (0);
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/float4.c

@@ -0,0 +1,62 @@
+/* Area:	ffi_call
+   Purpose:	Check denorm double value.
+   Limitations:	none.
+   PR:		PR26483.
+   Originator:	From the original ffitest.c  */
+
+/* { dg-do run } */
+/* { dg-options "-mieee" { target alpha*-*-* } } */
+
+#include "ffitest.h"
+#include "float.h"
+
+typedef union
+{
+  double d;
+  unsigned char c[sizeof (double)];
+} value_type;
+
+#define CANARY 0xba
+
+static double dblit(double d)
+{
+  return d;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  double d;
+  value_type result[2];
+  unsigned int i;
+
+  args[0] = &ffi_type_double;
+  values[0] = &d;
+  
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
+		     &ffi_type_double, args) == FFI_OK);
+  
+  d = DBL_MIN / 2;
+  
+  /* Put a canary in the return array.  This is a regression test for
+     a buffer overrun.  */
+  memset(result[1].c, CANARY, sizeof (double));
+
+  ffi_call(&cif, FFI_FN(dblit), &result[0].d, values);
+  
+  /* The standard delta check doesn't work for denorms.  Since we didn't do
+     any arithmetic, we should get the original result back, and hence an
+     exact check should be OK here.  */
+ 
+  CHECK(result[0].d == dblit(d));
+
+  /* Check the canary.  */
+  for (i = 0; i < sizeof (double); ++i)
+    CHECK(result[1].c[i] == CANARY);
+
+  exit(0);
+
+}

miniconda3/pkgs/libffi-3.4.4-h6a678d5_1/info/test/testsuite/libffi.call/float_va.c

@@ -0,0 +1,110 @@
+/* Area:        fp and variadics
+   Purpose:     check fp inputs and returns work on variadics, even the fixed params
+   Limitations: None
+   PR:          none
+   Originator:  <david.gilbert@linaro.org> 2011-01-25
+
+   Intended to stress the difference in ABI on ARM vfp
+*/
+
+/* { dg-do run } */
+
+#include <stdarg.h>
+
+#include "ffitest.h"
+
+/* prints out all the parameters, and returns the sum of them all.
+ * 'x' is the number of variadic parameters all of which are double in this test
+ */
+double float_va_fn(unsigned int x, double y,...)
+{
+  double total=0.0;
+  va_list ap;
+  unsigned int i;
+
+  total+=(double)x;
+  total+=y;
+
+  printf("%u: %.1f :", x, y);
+
+  va_start(ap, y);
+  for(i=0;i<x;i++)
+  {
+    double arg=va_arg(ap, double);
+    total+=arg;
+    printf(" %d:%.1f ", i, arg);
+  }
+  va_end(ap);
+
+  printf(" total: %.1f\n", total);
+
+  return total;
+}
+
+int main (void)
+{
+  ffi_cif    cif;
+
+  ffi_type    *arg_types[5];
+  void        *values[5];
+  double        doubles[5];
+  unsigned int firstarg;
+  double        resfp;
+
+  /* First test, pass float_va_fn(0,2.0) - note there are no actual
+   * variadic parameters, but it's declared variadic so the ABI may be
+   * different. */
+  /* Call it statically and then via ffi */
+  resfp=float_va_fn(0,2.0);
+  /* { dg-output "0: 2.0 : total: 2.0" } */
+  printf("compiled: %.1f\n", resfp);
+  /* { dg-output "\ncompiled: 2.0" } */
+
+  arg_types[0] = &ffi_type_uint;
+  arg_types[1] = &ffi_type_double;
+  arg_types[2] = NULL;
+  CHECK(ffi_prep_cif_var(&cif, FFI_DEFAULT_ABI, 2, 2,
+        &ffi_type_double, arg_types) == FFI_OK);
+
+  firstarg = 0;
+  doubles[0] = 2.0;
+  values[0] = &firstarg;
+  values[1] = &doubles[0];
+  ffi_call(&cif, FFI_FN(float_va_fn), &resfp, values);
+  /* { dg-output "\n0: 2.0 : total: 2.0" } */
+  printf("ffi: %.1f\n", resfp);
+  /* { dg-output "\nffi: 2.0" } */
+  CHECK_DOUBLE_EQ(resfp, 2);
+
+  /* Second test, float_va_fn(2,2.0,3.0,4.0), now with variadic params */
+  /* Call it statically and then via ffi */
+  resfp=float_va_fn(2,2.0,3.0,4.0);
+  /* { dg-output "\n2: 2.0 : 0:3.0  1:4.0  total: 11.0" } */
+  printf("compiled: %.1f\n", resfp);
+  /* { dg-output "\ncompiled: 11.0" } */
+  CHECK_DOUBLE_EQ(resfp, 11);
+
+  arg_types[0] = &ffi_type_uint;
+  arg_types[1] = &ffi_type_double;
+  arg_types[2] = &ffi_type_double;
+  arg_types[3] = &ffi_type_double;
+  arg_types[4] = NULL;
+  CHECK(ffi_prep_cif_var(&cif, FFI_DEFAULT_ABI, 2, 4,
+        &ffi_type_double, arg_types) == FFI_OK);
+
+  firstarg = 2;
+  doubles[0] = 2.0;
+  doubles[1] = 3.0;
+  doubles[2] = 4.0;
+  values[0] = &firstarg;
+  values[1] = &doubles[0];
+  values[2] = &doubles[1];
+  values[3] = &doubles[2];
+  ffi_call(&cif, FFI_FN(float_va_fn), &resfp, values);
+  /* { dg-output "\n2: 2.0 : 0:3.0  1:4.0  total: 11.0" } */
+  printf("ffi: %.1f\n", resfp);
+  /* { dg-output "\nffi: 11.0" } */
+  CHECK_DOUBLE_EQ(resfp, 11);
+
+  exit(0);
+}