diff --git a/python-cffi-Add-sw64-architecture.patch b/python-cffi-Add-sw64-architecture.patch new file mode 100644 index 0000000000000000000000000000000000000000..d07f942caa1ca6ab256598ddf46ac949e1edc2e3 --- /dev/null +++ b/python-cffi-Add-sw64-architecture.patch @@ -0,0 +1,944 @@ +From 11969b602923a532f47569fa742bcb53c68197d8 Mon Sep 17 00:00:00 2001 +From: wuzx +Date: Fri, 18 Nov 2022 14:10:53 +0800 +Subject: [PATCH] Add sw64 architecture + +Add sw64 architecture in file c/_cffi_backend.c c/libffi_sw_64/include/ffi.h c/libffi_sw_64/include/fficonfig.h c/libffi_sw_64/include/ffitarget.h and c/test_c.py to support sw64 architecture. + +Signed-off-by: wuzx +--- + c/_cffi_backend.c | 7 +- + c/libffi_sw_64/include/ffi.h | 515 +++++++++++++++++++++++++++++ + c/libffi_sw_64/include/fficonfig.h | 215 ++++++++++++ + c/libffi_sw_64/include/ffitarget.h | 92 ++++++ + c/test_c.py | 11 + + 5 files changed, 838 insertions(+), 2 deletions(-) + create mode 100644 c/libffi_sw_64/include/ffi.h + create mode 100644 c/libffi_sw_64/include/fficonfig.h + create mode 100644 c/libffi_sw_64/include/ffitarget.h + +diff --git a/c/_cffi_backend.c b/c/_cffi_backend.c +index ffecbf9..bad40e1 100644 +--- a/c/_cffi_backend.c ++++ b/c/_cffi_backend.c +@@ -5038,6 +5038,7 @@ _add_field(PyObject *interned_fields, PyObject *fname, CTypeDescrObject *ftype, + } + + #define SF_MSVC_BITFIELDS 0x01 ++#define SF_GCC_SW_64_BITFIELDS 0x02 + #define SF_GCC_ARM_BITFIELDS 0x02 + #define SF_GCC_X86_BITFIELDS 0x10 + +@@ -5057,7 +5058,7 @@ static int complete_sflags(int sflags) + { + /* add one of the SF_xxx_BITFIELDS flags if none is specified */ + if (!(sflags & (SF_MSVC_BITFIELDS | SF_GCC_ARM_BITFIELDS | +- SF_GCC_X86_BITFIELDS))) { ++ SF_GCC_X86_BITFIELDS | SF_GCC_SW_64_BITFIELDS))) { + #ifdef MS_WIN32 + sflags |= SF_MSVC_BITFIELDS; + #else +@@ -5065,6 +5066,8 @@ static int complete_sflags(int sflags) + sflags |= SF_GCC_X86_BITFIELDS; + # elif defined(__arm__) || defined(__aarch64__) + sflags |= SF_GCC_ARM_BITFIELDS; ++# elif defined(__sw_64__) ++ sflags |= SF_GCC_SW_64_BITFIELDS; + # else + sflags |= SF_GCC_X86_BITFIELDS; + # endif +@@ -5213,7 +5216,7 @@ static PyObject *b_complete_struct_or_union(PyObject *self, PyObject *args) + falign = (pack < falignorg) ? pack : falignorg; + + do_align = 1; +- if (!(sflags & SF_GCC_ARM_BITFIELDS) && fbitsize >= 0) { ++ if (!(sflags & SF_GCC_SW_64_BITFIELDS) && fbitsize >= 0) { + if (!(sflags & SF_MSVC_BITFIELDS)) { + /* GCC: anonymous bitfields (of any size) don't cause alignment */ + do_align = PyText_GetSize(fname) > 0; +diff --git a/c/libffi_sw_64/include/ffi.h b/c/libffi_sw_64/include/ffi.h +new file mode 100644 +index 0000000..691ec47 +--- /dev/null ++++ b/c/libffi_sw_64/include/ffi.h +@@ -0,0 +1,515 @@ ++/* -----------------------------------------------------------------*-C-*- ++ libffi 3.3-rc0 - Copyright (c) 2011, 2014 Anthony Green ++ - Copyright (c) 1996-2003, 2007, 2008 Red Hat, Inc. ++ ++ 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. ++ ++ ----------------------------------------------------------------------- */ ++ ++/* ------------------------------------------------------------------- ++ Most of the API is documented in doc/libffi.texi. ++ ++ The raw API is designed to bypass some of the argument packing and ++ unpacking on architectures for which it can be avoided. Routines ++ are provided to emulate the raw API if the underlying platform ++ doesn't allow faster implementation. ++ ++ More details on the raw API can be found in: ++ ++ http://gcc.gnu.org/ml/java/1999-q3/msg00138.html ++ ++ and ++ ++ http://gcc.gnu.org/ml/java/1999-q3/msg00174.html ++ -------------------------------------------------------------------- */ ++ ++#ifndef LIBFFI_H ++#define LIBFFI_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Specify which architecture libffi is configured for. */ ++#ifndef SW_64_WIN64 ++#define SW_64_WIN64 ++#endif ++ ++/* ---- System configuration information --------------------------------- */ ++ ++#include ++ ++#ifndef LIBFFI_ASM ++ ++#if defined(_MSC_VER) && !defined(__clang__) ++#define __attribute__(X) ++#endif ++ ++#include ++#include ++ ++/* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example). ++ But we can find it either under the correct ANSI name, or under GNU ++ C's internal name. */ ++ ++#define FFI_64_BIT_MAX 9223372036854775807 ++ ++#ifdef LONG_LONG_MAX ++# define FFI_LONG_LONG_MAX LONG_LONG_MAX ++#else ++# ifdef LLONG_MAX ++# define FFI_LONG_LONG_MAX LLONG_MAX ++# ifdef _AIX52 /* or newer has C99 LLONG_MAX */ ++# undef FFI_64_BIT_MAX ++# define FFI_64_BIT_MAX 9223372036854775807LL ++# endif /* _AIX52 or newer */ ++# else ++# ifdef __GNUC__ ++# define FFI_LONG_LONG_MAX __LONG_LONG_MAX__ ++# endif ++# ifdef _AIX /* AIX 5.1 and earlier have LONGLONG_MAX */ ++# ifndef __PPC64__ ++# if defined (__IBMC__) || defined (__IBMCPP__) ++# define FFI_LONG_LONG_MAX LONGLONG_MAX ++# endif ++# endif /* __PPC64__ */ ++# undef FFI_64_BIT_MAX ++# define FFI_64_BIT_MAX 9223372036854775807LL ++# endif ++# endif ++#endif ++ ++/* The closure code assumes that this works on pointers, i.e. a size_t ++ can hold a pointer. */ ++ ++typedef struct _ffi_type ++{ ++ size_t size; ++ unsigned short alignment; ++ unsigned short type; ++ struct _ffi_type **elements; ++} ffi_type; ++ ++/* Need minimal decorations for DLLs to work on Windows. GCC has ++ autoimport and autoexport. Always mark externally visible symbols ++ as dllimport for MSVC clients, even if it means an extra indirection ++ when using the static version of the library. ++ Besides, as a workaround, they can define FFI_BUILDING if they ++ *know* they are going to link with the static library. */ ++#if defined _MSC_VER ++# if defined FFI_BUILDING_DLL /* Building libffi.DLL with msvcc.sh */ ++# define FFI_API __declspec(dllexport) ++# elif !defined FFI_BUILDING /* Importing libffi.DLL */ ++# define FFI_API __declspec(dllimport) ++# else /* Building/linking static library */ ++# define FFI_API ++# endif ++#else ++# define FFI_API ++#endif ++ ++/* The externally visible type declarations also need the MSVC DLL ++ decorations, or they will not be exported from the object file. */ ++#if defined LIBFFI_HIDE_BASIC_TYPES ++# define FFI_EXTERN FFI_API ++#else ++# define FFI_EXTERN extern FFI_API ++#endif ++ ++#ifndef LIBFFI_HIDE_BASIC_TYPES ++#if SCHAR_MAX == 127 ++# define ffi_type_uchar ffi_type_uint8 ++# define ffi_type_schar ffi_type_sint8 ++#else ++ #error "char size not supported" ++#endif ++ ++#if SHRT_MAX == 32767 ++# define ffi_type_ushort ffi_type_uint16 ++# define ffi_type_sshort ffi_type_sint16 ++#elif SHRT_MAX == 2147483647 ++# define ffi_type_ushort ffi_type_uint32 ++# define ffi_type_sshort ffi_type_sint32 ++#else ++ #error "short size not supported" ++#endif ++ ++#if INT_MAX == 32767 ++# define ffi_type_uint ffi_type_uint16 ++# define ffi_type_sint ffi_type_sint16 ++#elif INT_MAX == 2147483647 ++# define ffi_type_uint ffi_type_uint32 ++# define ffi_type_sint ffi_type_sint32 ++#elif INT_MAX == 9223372036854775807 ++# define ffi_type_uint ffi_type_uint64 ++# define ffi_type_sint ffi_type_sint64 ++#else ++ #error "int size not supported" ++#endif ++ ++#if LONG_MAX == 2147483647 ++# if FFI_LONG_LONG_MAX != FFI_64_BIT_MAX ++ #error "no 64-bit data type supported" ++# endif ++#elif LONG_MAX != FFI_64_BIT_MAX ++ #error "long size not supported" ++#endif ++ ++#if LONG_MAX == 2147483647 ++# define ffi_type_ulong ffi_type_uint32 ++# define ffi_type_slong ffi_type_sint32 ++#elif LONG_MAX == FFI_64_BIT_MAX ++# define ffi_type_ulong ffi_type_uint64 ++# define ffi_type_slong ffi_type_sint64 ++#else ++ #error "long size not supported" ++#endif ++ ++/* These are defined in types.c. */ ++FFI_EXTERN ffi_type ffi_type_void; ++FFI_EXTERN ffi_type ffi_type_uint8; ++FFI_EXTERN ffi_type ffi_type_sint8; ++FFI_EXTERN ffi_type ffi_type_uint16; ++FFI_EXTERN ffi_type ffi_type_sint16; ++FFI_EXTERN ffi_type ffi_type_uint32; ++FFI_EXTERN ffi_type ffi_type_sint32; ++FFI_EXTERN ffi_type ffi_type_uint64; ++FFI_EXTERN ffi_type ffi_type_sint64; ++FFI_EXTERN ffi_type ffi_type_float; ++FFI_EXTERN ffi_type ffi_type_double; ++FFI_EXTERN ffi_type ffi_type_pointer; ++ ++#if 0 ++FFI_EXTERN ffi_type ffi_type_longdouble; ++#else ++#define ffi_type_longdouble ffi_type_double ++#endif ++ ++#ifdef FFI_TARGET_HAS_COMPLEX_TYPE ++FFI_EXTERN ffi_type ffi_type_complex_float; ++FFI_EXTERN ffi_type ffi_type_complex_double; ++#if 0 ++FFI_EXTERN ffi_type ffi_type_complex_longdouble; ++#else ++#define ffi_type_complex_longdouble ffi_type_complex_double ++#endif ++#endif ++#endif /* LIBFFI_HIDE_BASIC_TYPES */ ++ ++typedef enum { ++ FFI_OK = 0, ++ FFI_BAD_TYPEDEF, ++ FFI_BAD_ABI ++} ffi_status; ++ ++typedef struct { ++ ffi_abi abi; ++ unsigned nargs; ++ ffi_type **arg_types; ++ ffi_type *rtype; ++ unsigned bytes; ++ unsigned flags; ++#ifdef FFI_EXTRA_CIF_FIELDS ++ FFI_EXTRA_CIF_FIELDS; ++#endif ++} ffi_cif; ++ ++/* ---- Definitions for the raw API -------------------------------------- */ ++ ++#ifndef FFI_SIZEOF_ARG ++# if LONG_MAX == 2147483647 ++# define FFI_SIZEOF_ARG 4 ++# elif LONG_MAX == FFI_64_BIT_MAX ++# define FFI_SIZEOF_ARG 8 ++# endif ++#endif ++ ++#ifndef FFI_SIZEOF_JAVA_RAW ++# define FFI_SIZEOF_JAVA_RAW FFI_SIZEOF_ARG ++#endif ++ ++typedef union { ++ ffi_sarg sint; ++ ffi_arg uint; ++ float flt; ++ char data[FFI_SIZEOF_ARG]; ++ void* ptr; ++} ffi_raw; ++ ++#if FFI_SIZEOF_JAVA_RAW == 4 && FFI_SIZEOF_ARG == 8 ++/* This is a special case for mips64/n32 ABI (and perhaps others) where ++ sizeof(void *) is 4 and FFI_SIZEOF_ARG is 8. */ ++typedef union { ++ signed int sint; ++ unsigned int uint; ++ float flt; ++ char data[FFI_SIZEOF_JAVA_RAW]; ++ void* ptr; ++} ffi_java_raw; ++#else ++typedef ffi_raw ffi_java_raw; ++#endif ++ ++ ++FFI_API ++void ffi_raw_call (ffi_cif *cif, ++ void (*fn)(void), ++ void *rvalue, ++ ffi_raw *avalue); ++ ++FFI_API void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw); ++FFI_API void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args); ++FFI_API size_t ffi_raw_size (ffi_cif *cif); ++ ++/* This is analogous to the raw API, except it uses Java parameter ++ packing, even on 64-bit machines. I.e. on 64-bit machines longs ++ and doubles are followed by an empty 64-bit word. */ ++ ++#if !FFI_NATIVE_RAW_API ++FFI_API ++void ffi_java_raw_call (ffi_cif *cif, ++ void (*fn)(void), ++ void *rvalue, ++ ffi_java_raw *avalue); ++#endif ++ ++FFI_API ++void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw); ++FFI_API ++void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args); ++FFI_API ++size_t ffi_java_raw_size (ffi_cif *cif); ++ ++/* ---- Definitions for closures ----------------------------------------- */ ++ ++#if FFI_CLOSURES ++ ++#ifdef _MSC_VER ++__declspec(align(8)) ++#endif ++typedef struct { ++#if 0 ++ void *trampoline_table; ++ void *trampoline_table_entry; ++#else ++ char tramp[FFI_TRAMPOLINE_SIZE]; ++#endif ++ ffi_cif *cif; ++ void (*fun)(ffi_cif*,void*,void**,void*); ++ void *user_data; ++} ffi_closure ++#ifdef __GNUC__ ++ __attribute__((aligned (8))) ++#endif ++ ; ++ ++#ifndef __GNUC__ ++# ifdef __sgi ++# pragma pack 0 ++# endif ++#endif ++ ++FFI_API void *ffi_closure_alloc (size_t size, void **code); ++FFI_API void ffi_closure_free (void *); ++ ++FFI_API ffi_status ++ffi_prep_closure (ffi_closure*, ++ ffi_cif *, ++ void (*fun)(ffi_cif*,void*,void**,void*), ++ void *user_data) ++#if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 405) ++ __attribute__((deprecated ("use ffi_prep_closure_loc instead"))) ++#elif defined(__GNUC__) && __GNUC__ >= 3 ++ __attribute__((deprecated)) ++#endif ++ ; ++ ++FFI_API ffi_status ++ffi_prep_closure_loc (ffi_closure*, ++ ffi_cif *, ++ void (*fun)(ffi_cif*,void*,void**,void*), ++ void *user_data, ++ void*codeloc); ++ ++#ifdef __sgi ++# pragma pack 8 ++#endif ++typedef struct { ++#if 0 ++ void *trampoline_table; ++ void *trampoline_table_entry; ++#else ++ char tramp[FFI_TRAMPOLINE_SIZE]; ++#endif ++ ffi_cif *cif; ++ ++#if !FFI_NATIVE_RAW_API ++ ++ /* If this is enabled, then a raw closure has the same layout ++ as a regular closure. We use this to install an intermediate ++ handler to do the transaltion, void** -> ffi_raw*. */ ++ ++ void (*translate_args)(ffi_cif*,void*,void**,void*); ++ void *this_closure; ++ ++#endif ++ ++ void (*fun)(ffi_cif*,void*,ffi_raw*,void*); ++ void *user_data; ++ ++} ffi_raw_closure; ++ ++typedef struct { ++#if 0 ++ void *trampoline_table; ++ void *trampoline_table_entry; ++#else ++ char tramp[FFI_TRAMPOLINE_SIZE]; ++#endif ++ ++ ffi_cif *cif; ++ ++#if !FFI_NATIVE_RAW_API ++ ++ /* If this is enabled, then a raw closure has the same layout ++ as a regular closure. We use this to install an intermediate ++ handler to do the translation, void** -> ffi_raw*. */ ++ ++ void (*translate_args)(ffi_cif*,void*,void**,void*); ++ void *this_closure; ++ ++#endif ++ ++ void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*); ++ void *user_data; ++ ++} ffi_java_raw_closure; ++ ++FFI_API ffi_status ++ffi_prep_raw_closure (ffi_raw_closure*, ++ ffi_cif *cif, ++ void (*fun)(ffi_cif*,void*,ffi_raw*,void*), ++ void *user_data); ++ ++FFI_API ffi_status ++ffi_prep_raw_closure_loc (ffi_raw_closure*, ++ ffi_cif *cif, ++ void (*fun)(ffi_cif*,void*,ffi_raw*,void*), ++ void *user_data, ++ void *codeloc); ++ ++#if !FFI_NATIVE_RAW_API ++FFI_API ffi_status ++ffi_prep_java_raw_closure (ffi_java_raw_closure*, ++ ffi_cif *cif, ++ void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*), ++ void *user_data); ++ ++FFI_API ffi_status ++ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*, ++ ffi_cif *cif, ++ void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*), ++ void *user_data, ++ void *codeloc); ++#endif ++ ++#endif /* FFI_CLOSURES */ ++ ++#if FFI_GO_CLOSURES ++ ++typedef struct { ++ void *tramp; ++ ffi_cif *cif; ++ void (*fun)(ffi_cif*,void*,void**,void*); ++} ffi_go_closure; ++ ++FFI_API ffi_status ffi_prep_go_closure (ffi_go_closure*, ffi_cif *, ++ void (*fun)(ffi_cif*,void*,void**,void*)); ++ ++FFI_API void ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue, ++ void **avalue, void *closure); ++ ++#endif /* FFI_GO_CLOSURES */ ++ ++/* ---- Public interface definition -------------------------------------- */ ++ ++FFI_API ++ffi_status ffi_prep_cif(ffi_cif *cif, ++ ffi_abi abi, ++ unsigned int nargs, ++ ffi_type *rtype, ++ ffi_type **atypes); ++ ++FFI_API ++ffi_status ffi_prep_cif_var(ffi_cif *cif, ++ ffi_abi abi, ++ unsigned int nfixedargs, ++ unsigned int ntotalargs, ++ ffi_type *rtype, ++ ffi_type **atypes); ++ ++FFI_API ++void ffi_call(ffi_cif *cif, ++ void (*fn)(void), ++ void *rvalue, ++ void **avalue); ++ ++FFI_API ++ffi_status ffi_get_struct_offsets (ffi_abi abi, ffi_type *struct_type, ++ size_t *offsets); ++ ++/* Useful for eliminating compiler warnings. */ ++#define FFI_FN(f) ((void (*)(void))f) ++ ++/* ---- Definitions shared with assembly code ---------------------------- */ ++ ++#endif ++ ++/* If these change, update src/mips/ffitarget.h. */ ++#define FFI_TYPE_VOID 0 ++#define FFI_TYPE_INT 1 ++#define FFI_TYPE_FLOAT 2 ++#define FFI_TYPE_DOUBLE 3 ++#if 0 ++#define FFI_TYPE_LONGDOUBLE 4 ++#else ++#define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE ++#endif ++#define FFI_TYPE_UINT8 5 ++#define FFI_TYPE_SINT8 6 ++#define FFI_TYPE_UINT16 7 ++#define FFI_TYPE_SINT16 8 ++#define FFI_TYPE_UINT32 9 ++#define FFI_TYPE_SINT32 10 ++#define FFI_TYPE_UINT64 11 ++#define FFI_TYPE_SINT64 12 ++#define FFI_TYPE_STRUCT 13 ++#define FFI_TYPE_POINTER 14 ++#define FFI_TYPE_COMPLEX 15 ++ ++/* This should always refer to the last type code (for sanity checks). */ ++#define FFI_TYPE_LAST FFI_TYPE_COMPLEX ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/c/libffi_sw_64/include/fficonfig.h b/c/libffi_sw_64/include/fficonfig.h +new file mode 100644 +index 0000000..5768c29 +--- /dev/null ++++ b/c/libffi_sw_64/include/fficonfig.h +@@ -0,0 +1,215 @@ ++/* fficonfig.h. Generated from fficonfig.h.in by configure. */ ++/* fficonfig.h.in. Generated from configure.ac by autoheader. */ ++ ++/* Define if building universal (internal helper macro) */ ++/* #undef 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. ++ */ ++/* #undef CRAY_STACKSEG_END */ ++ ++/* Define to 1 if using `alloca.c'. */ ++/* #undef C_ALLOCA */ ++ ++/* Define to the flags needed for the .section .eh_frame directive. */ ++/* #undef EH_FRAME_FLAGS */ ++ ++/* Define this if you want extra debugging. */ ++/* #undef FFI_DEBUG */ ++ ++/* Cannot use PROT_EXEC on this target, so, we revert to alternative means */ ++/* #undef FFI_EXEC_TRAMPOLINE_TABLE */ ++ ++/* Define this if you want to enable pax emulated trampolines */ ++/* #undef FFI_MMAP_EXEC_EMUTRAMP_PAX */ ++ ++/* Cannot use malloc on this target, so, we revert to alternative means */ ++/* #undef FFI_MMAP_EXEC_WRIT */ ++ ++/* Define this if you do not want support for the raw API. */ ++/* #undef FFI_NO_RAW_API */ ++ ++/* Define this if you do not want support for aggregate types. */ ++/* #undef FFI_NO_STRUCTS */ ++ ++/* Define to 1 if you have `alloca', as a function or macro. */ ++#define HAVE_ALLOCA 1 ++ ++/* Define to 1 if you have and it should be used (not on Ultrix). ++ */ ++/* #undef HAVE_ALLOCA_H */ ++ ++/* Define if your assembler supports .cfi_* directives. */ ++/* #undef HAVE_AS_CFI_PSEUDO_OP */ ++ ++/* Define if your assembler supports .register. */ ++/* #undef HAVE_AS_REGISTER_PSEUDO_OP */ ++ ++/* Define if the compiler uses zarch features. */ ++/* #undef HAVE_AS_S390_ZARCH */ ++ ++/* Define if your assembler and linker support unaligned PC relative relocs. ++ */ ++/* #undef HAVE_AS_SPARC_UA_PCREL */ ++ ++/* Define if your assembler supports unwind section type. */ ++/* #undef HAVE_AS_X86_64_UNWIND_SECTION_TYPE */ ++ ++/* Define if your assembler supports PC relative relocs. */ ++/* #undef HAVE_AS_X86_PCREL */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef HAVE_DLFCN_H */ ++ ++/* Define if __attribute__((visibility("hidden"))) is supported. */ ++/* #undef HAVE_HIDDEN_VISIBILITY_ATTRIBUTE */ ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_INTTYPES_H 1 ++ ++/* Define if you have the long double type and it is bigger than a double */ ++/* #undef HAVE_LONG_DOUBLE */ ++ ++/* Define if you support more than one size of the long double type */ ++/* #undef HAVE_LONG_DOUBLE_VARIANT */ ++ ++/* Define to 1 if you have the `memcpy' function. */ ++/* #undef HAVE_MEMCPY */ ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_MEMORY_H 1 ++ ++/* Define to 1 if you have the `mkostemp' function. */ ++/* #undef HAVE_MKOSTEMP */ ++ ++/* Define to 1 if you have the `mmap' function. */ ++/* #undef HAVE_MMAP */ ++ ++/* Define if mmap with MAP_ANON(YMOUS) works. */ ++/* #undef HAVE_MMAP_ANON */ ++ ++/* Define if mmap of /dev/zero works. */ ++/* #undef HAVE_MMAP_DEV_ZERO */ ++ ++/* Define if read-only mmap of a plain file works. */ ++/* #undef HAVE_MMAP_FILE */ ++ ++/* Define if .eh_frame sections should be read-only. */ ++/* #undef HAVE_RO_EH_FRAME */ ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_STDINT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_STDLIB_H 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef HAVE_STRINGS_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_STRING_H 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef HAVE_SYS_MMAN_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_SYS_STAT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_SYS_TYPES_H 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef HAVE_UNISTD_H */ ++ ++/* Define to 1 if GNU symbol versioning is used for libatomic. */ ++/* #undef LIBFFI_GNU_SYMBOL_VERSIONING */ ++ ++/* Define to the sub-directory where libtool stores uninstalled libraries. */ ++#define LT_OBJDIR ".libs/" ++ ++/* Name of package */ ++#define PACKAGE "libffi" ++ ++/* Define to the address where bug reports for this package should be sent. */ ++#define PACKAGE_BUGREPORT "http://github.com/libffi/libffi/issues" ++ ++/* Define to the full name of this package. */ ++#define PACKAGE_NAME "libffi" ++ ++/* Define to the full name and version of this package. */ ++#define PACKAGE_STRING "libffi 3.3-rc0" ++ ++/* Define to the one symbol short name of this package. */ ++#define PACKAGE_TARNAME "libffi" ++ ++/* Define to the home page for this package. */ ++#define PACKAGE_URL "" ++ ++/* Define to the version of this package. */ ++#define PACKAGE_VERSION "3.3-rc0" ++ ++/* The size of `double', as computed by sizeof. */ ++#define SIZEOF_DOUBLE 8 ++ ++/* The size of `long double', as computed by sizeof. */ ++#define SIZEOF_LONG_DOUBLE 8 ++ ++/* The size of `size_t', as computed by sizeof. */ ++#define SIZEOF_SIZE_T 8 ++ ++/* 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 */ ++/* #undef STACK_DIRECTION */ ++ ++/* Define to 1 if you have the ANSI C header files. */ ++#define STDC_HEADERS 1 ++ ++/* Define if symbols are underscored. */ ++/* #undef SYMBOL_UNDERSCORE */ ++ ++/* Define this if you are using Purify and want to suppress spurious messages. ++ */ ++/* #undef USING_PURIFY */ ++ ++/* Version number of package */ ++#define VERSION "3.3-rc0" ++ ++/* 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 does not define. */ ++/* #undef 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/c/libffi_sw_64/include/ffitarget.h b/c/libffi_sw_64/include/ffitarget.h +new file mode 100644 +index 0000000..3e620de +--- /dev/null ++++ b/c/libffi_sw_64/include/ffitarget.h +@@ -0,0 +1,92 @@ ++/* Copyright (c) 2009, 2010, 2011, 2012 ARM Ltd. ++ ++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 ++ ++#ifndef LIBFFI_ASM ++#ifdef __ILP32__ ++#define FFI_SIZEOF_ARG 8 ++#define FFI_SIZEOF_JAVA_RAW 4 ++typedef unsigned long long ffi_arg; ++typedef signed long long ffi_sarg; ++#elif defined(_M_SW_64) ++#define FFI_SIZEOF_ARG 8 ++typedef unsigned long long ffi_arg; ++typedef signed long long ffi_sarg; ++#else ++typedef unsigned long ffi_arg; ++typedef signed long ffi_sarg; ++#endif ++ ++typedef enum ffi_abi ++ { ++ FFI_FIRST_ABI = 0, ++ FFI_SYSV, ++ FFI_LAST_ABI, ++ FFI_DEFAULT_ABI = FFI_SYSV ++ } ffi_abi; ++#endif ++ ++/* ---- Definitions for closures ----------------------------------------- */ ++ ++#define FFI_CLOSURES 1 ++#define FFI_NATIVE_RAW_API 0 ++ ++#if defined (FFI_EXEC_TRAMPOLINE_TABLE) && FFI_EXEC_TRAMPOLINE_TABLE ++ ++#ifdef __MACH__ ++#define FFI_TRAMPOLINE_SIZE 16 ++#define FFI_TRAMPOLINE_CLOSURE_OFFSET 16 ++#else ++#error "No trampoline table implementation" ++#endif ++ ++#else ++#define FFI_TRAMPOLINE_SIZE 24 ++#define FFI_TRAMPOLINE_CLOSURE_OFFSET FFI_TRAMPOLINE_SIZE ++#endif ++ ++#ifdef _M_SW_64 ++#define FFI_EXTRA_CIF_FIELDS unsigned is_variadic ++#endif ++ ++/* ---- Internal ---- */ ++ ++#if defined (__APPLE__) ++#define FFI_TARGET_SPECIFIC_VARIADIC ++#define FFI_EXTRA_CIF_FIELDS unsigned aarch64_nfixedargs ++#elif !defined(_M_SW_64) ++/* iOS and Windows reserve x18 for the system. Disable Go closures until ++ a new static chain is chosen. */ ++#define FFI_GO_CLOSURES 1 ++#endif ++ ++#ifndef _M_SW_64 ++/* No complex type on Windows */ ++#define FFI_TARGET_HAS_COMPLEX_TYPE ++#endif ++ ++#endif +diff --git a/c/test_c.py b/c/test_c.py +index 654584d..fac0551 100644 +--- a/c/test_c.py ++++ b/c/test_c.py +@@ -3403,6 +3403,9 @@ def _test_bitfield_details(flag): + elif flag & SF_GCC_X86_BITFIELDS: + assert sizeof(BStruct) == 5 + assert alignof(BStruct) == 1 ++ elif flag & SF_GCC_SW_64_BITFIELDS: ++ assert sizeof(BStruct) == 6 ++ assert alignof(BStruct) == 2 + elif flag & SF_GCC_ARM_BITFIELDS: + assert sizeof(BStruct) == 6 + assert alignof(BStruct) == 2 +@@ -3422,6 +3425,10 @@ def _test_bitfield_details(flag): + assert typeoffsetof(BStruct, 'c') == (BChar, 4) + assert sizeof(BStruct) == 5 + assert alignof(BStruct) == 1 ++ elif flag & SF_GCC_SW_64_BITFIELDS: ++ assert typeoffsetof(BStruct, 'c') == (BChar, 4) ++ assert sizeof(BStruct) == 8 ++ assert alignof(BStruct) == 4 + elif flag & SF_GCC_ARM_BITFIELDS: + assert typeoffsetof(BStruct, 'c') == (BChar, 4) + assert sizeof(BStruct) == 8 +@@ -3431,6 +3438,7 @@ def _test_bitfield_details(flag): + + + SF_MSVC_BITFIELDS = 0x01 ++SF_GCC_SW_64_BITFIELDS = 0x02 + SF_GCC_ARM_BITFIELDS = 0x02 + SF_GCC_X86_BITFIELDS = 0x10 + +@@ -3445,6 +3453,9 @@ def test_bitfield_as_x86_gcc(): + def test_bitfield_as_msvc(): + _test_bitfield_details(flag=SF_MSVC_BITFIELDS|SF_GCC_LITTLE_ENDIAN) + ++def test_bitfield_as_sw_64_gcc(): ++ _test_bitfield_details(flag=SF_GCC_SW_64_BITFIELDS|SF_GCC_LITTLE_ENDIAN) ++ + def test_bitfield_as_arm_gcc(): + _test_bitfield_details(flag=SF_GCC_ARM_BITFIELDS|SF_GCC_LITTLE_ENDIAN) + +-- +2.33.0 + diff --git a/python-cffi.spec b/python-cffi.spec index a0283830f23e54b64c274e68ccc48993d2bff82b..2ad3ec79abcb5628a56c5f4ae4d0bebea902e542 100644 --- a/python-cffi.spec +++ b/python-cffi.spec @@ -6,11 +6,12 @@ based on C-like declarations that you can often copy-paste from header files or Name: python-%{_name} Version: 1.15.0 -Release: 2 +Release: 3 Summary: %{_summary} License: MIT URL: http://cffi.readthedocs.org Source0: https://files.pythonhosted.org/packages/source/c/cffi/%{_name}-%{version}.tar.gz +Patch1: python-cffi-Add-sw64-architecture.patch Buildrequires: libffi-devel gcc-c++ gcc python3-sphinx @@ -30,6 +31,12 @@ Buildrequires: python3-devel python3-pycparser python3-pytest python3-setuptool %prep %autosetup -n %{_name}-%{version} -p1 +%ifnarch sw_64 +%patch1 -R -p1 +%endif +%ifarch sw_64 +cp c/libffi_arm64/ffi.lib c/libffi_sw_64/ffi.lib +%endif %build %py3_build @@ -52,6 +59,9 @@ PYTHONPATH=%{buildroot}%{python3_sitearch} %{__python3} -m pytest c/ testing/ %doc PKG-INFO README.md %changelog +* Wed Oct 19 2022 wuzx - 1.15.0-3 +- add sw64 patch + * Mon Jun 20 2022 tanyulong - 1.15.0-2 - Delete unnecessary gdb from BuildRequires